x/urfave-cli
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #1370 from urfave/unshadow-context

Browse Source 
Unshadow `context` package
This commit is contained in:
Dan Buch 2022-04-24 07:56:00 -04:00 committed by GitHub
commit 801780fcc1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 214 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
altsrc/flag.go
View File

@ -13,18 +13,18 @@ import (
// allows a value to be set on the existing parsed flags. // allows a value to be set on the existing parsed flags.
type FlagInputSourceExtension interface { type FlagInputSourceExtension interface {
cli.Flag cli.Flag
ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error
} }
// ApplyInputSourceValues iterates over all provided flags and // ApplyInputSourceValues iterates over all provided flags and
// executes ApplyInputSourceValue on flags implementing the // executes ApplyInputSourceValue on flags implementing the
// FlagInputSourceExtension interface to initialize these flags // FlagInputSourceExtension interface to initialize these flags
// to an alternate input source. // to an alternate input source.
func ApplyInputSourceValues(context *cli.Context, inputSourceContext InputSourceContext, flags []cli.Flag) error { func ApplyInputSourceValues(cCtx *cli.Context, inputSourceContext InputSourceContext, flags []cli.Flag) error {
for _, f := range flags { for _, f := range flags {
inputSourceExtendedFlag, isType := f.(FlagInputSourceExtension) inputSourceExtendedFlag, isType := f.(FlagInputSourceExtension)
if isType { if isType {
err := inputSourceExtendedFlag.ApplyInputSourceValue(context, inputSourceContext) err := inputSourceExtendedFlag.ApplyInputSourceValue(cCtx, inputSourceContext)
if err != nil { if err != nil {
return err return err
} }
@ -38,34 +38,34 @@ func ApplyInputSourceValues(context *cli.Context, inputSourceContext InputSource
// input source based on the func provided. If there is no error it will then apply the new input source to any flags // input source based on the func provided. If there is no error it will then apply the new input source to any flags
// that are supported by the input source // that are supported by the input source
func InitInputSource(flags []cli.Flag, createInputSource func() (InputSourceContext, error)) cli.BeforeFunc { func InitInputSource(flags []cli.Flag, createInputSource func() (InputSourceContext, error)) cli.BeforeFunc {
return func(context *cli.Context) error { return func(cCtx *cli.Context) error {
inputSource, err := createInputSource() inputSource, err := createInputSource()
if err != nil { if err != nil {
return fmt.Errorf("Unable to create input source: inner error: \n'%v'", err.Error()) return fmt.Errorf("Unable to create input source: inner error: \n'%v'", err.Error())
} }
return ApplyInputSourceValues(context, inputSource, flags) return ApplyInputSourceValues(cCtx, inputSource, flags)
} }
} }
// InitInputSourceWithContext is used to to setup an InputSourceContext on a cli.Command Before method. It will create a new // InitInputSourceWithContext is used to to setup an InputSourceContext on a cli.Command Before method. It will create a new
// input source based on the func provided with potentially using existing cli.Context values to initialize itself. If there is // input source based on the func provided with potentially using existing cli.Context values to initialize itself. If there is
// no error it will then apply the new input source to any flags that are supported by the input source // no error it will then apply the new input source to any flags that are supported by the input source
func InitInputSourceWithContext(flags []cli.Flag, createInputSource func(context *cli.Context) (InputSourceContext, error)) cli.BeforeFunc { func InitInputSourceWithContext(flags []cli.Flag, createInputSource func(cCtx *cli.Context) (InputSourceContext, error)) cli.BeforeFunc {
return func(context *cli.Context) error { return func(cCtx *cli.Context) error {
inputSource, err := createInputSource(context) inputSource, err := createInputSource(cCtx)
if err != nil { if err != nil {
return fmt.Errorf("Unable to create input source with context: inner error: \n'%v'", err.Error()) return fmt.Errorf("Unable to create input source with context: inner error: \n'%v'", err.Error())
} }
return ApplyInputSourceValues(context, inputSource, flags) return ApplyInputSourceValues(cCtx, inputSource, flags)
} }
} }
// ApplyInputSourceValue applies a generic value to the flagSet if required // ApplyInputSourceValue applies a generic value to the flagSet if required
func (f *GenericFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *GenericFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) { if !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
value, err := isc.Generic(f.GenericFlag.Name) value, err := isc.Generic(f.GenericFlag.Name)
if err != nil { if err != nil {
return err return err
@ -82,9 +82,9 @@ func (f *GenericFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourc
} }
// ApplyInputSourceValue applies a StringSlice value to the flagSet if required // ApplyInputSourceValue applies a StringSlice value to the flagSet if required
func (f *StringSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *StringSliceFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) { if !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
value, err := isc.StringSlice(f.StringSliceFlag.Name) value, err := isc.StringSlice(f.StringSliceFlag.Name)
if err != nil { if err != nil {
return err return err
@ -104,9 +104,9 @@ func (f *StringSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputS
} }
// ApplyInputSourceValue applies a IntSlice value if required // ApplyInputSourceValue applies a IntSlice value if required
func (f *IntSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *IntSliceFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) { if !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
value, err := isc.IntSlice(f.IntSliceFlag.Name) value, err := isc.IntSlice(f.IntSliceFlag.Name)
if err != nil { if err != nil {
return err return err
@ -126,9 +126,9 @@ func (f *IntSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputSour
} }
// ApplyInputSourceValue applies a Bool value to the flagSet if required // ApplyInputSourceValue applies a Bool value to the flagSet if required
func (f *BoolFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *BoolFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) { if !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
value, err := isc.Bool(f.BoolFlag.Name) value, err := isc.Bool(f.BoolFlag.Name)
if err != nil { if err != nil {
return err return err
@ -144,9 +144,9 @@ func (f *BoolFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceCo
} }
// ApplyInputSourceValue applies a String value to the flagSet if required // ApplyInputSourceValue applies a String value to the flagSet if required
func (f *StringFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *StringFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) { if !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
value, err := isc.String(f.StringFlag.Name) value, err := isc.String(f.StringFlag.Name)
if err != nil { if err != nil {
return err return err
@ -162,9 +162,9 @@ func (f *StringFlag) ApplyInputSourceValue(context *cli.Context, isc InputSource
} }
// ApplyInputSourceValue applies a Path value to the flagSet if required // ApplyInputSourceValue applies a Path value to the flagSet if required
func (f *PathFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *PathFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) { if !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
value, err := isc.String(f.PathFlag.Name) value, err := isc.String(f.PathFlag.Name)
if err != nil { if err != nil {
return err return err
@ -190,9 +190,9 @@ func (f *PathFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceCo
} }
// ApplyInputSourceValue applies a int value to the flagSet if required // ApplyInputSourceValue applies a int value to the flagSet if required
func (f *IntFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *IntFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) { if !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
value, err := isc.Int(f.IntFlag.Name) value, err := isc.Int(f.IntFlag.Name)
if err != nil { if err != nil {
return err return err
@ -208,9 +208,9 @@ func (f *IntFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceCon
} }
// ApplyInputSourceValue applies a Duration value to the flagSet if required // ApplyInputSourceValue applies a Duration value to the flagSet if required
func (f *DurationFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *DurationFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) { if !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
value, err := isc.Duration(f.DurationFlag.Name) value, err := isc.Duration(f.DurationFlag.Name)
if err != nil { if err != nil {
return err return err
@ -226,9 +226,9 @@ func (f *DurationFlag) ApplyInputSourceValue(context *cli.Context, isc InputSour
} }
// ApplyInputSourceValue applies a Float64 value to the flagSet if required // ApplyInputSourceValue applies a Float64 value to the flagSet if required
func (f *Float64Flag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error { func (f *Float64Flag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
if f.set != nil { if f.set != nil {
if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) { if !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
value, err := isc.Float64(f.Float64Flag.Name) value, err := isc.Float64(f.Float64Flag.Name)
if err != nil { if err != nil {
return err return err

6
altsrc/json_source_context.go
View File

@ -16,9 +16,9 @@ import (
// variables from a file containing JSON data with the file name defined // variables from a file containing JSON data with the file name defined
// by the given flag. // by the given flag.
func NewJSONSourceFromFlagFunc(flag string) func(c *cli.Context) (InputSourceContext, error) { func NewJSONSourceFromFlagFunc(flag string) func(c *cli.Context) (InputSourceContext, error) {
return func(context *cli.Context) (InputSourceContext, error) { return func(cCtx *cli.Context) (InputSourceContext, error) {
if context.IsSet(flag) { if cCtx.IsSet(flag) {
return NewJSONSourceFromFile(context.String(flag)) return NewJSONSourceFromFile(cCtx.String(flag))
} }
return defaultInputSource() return defaultInputSource()

8
altsrc/toml_file_loader.go
View File

@ -85,10 +85,10 @@ func NewTomlSourceFromFile(file string) (InputSourceContext, error) {
} }
// NewTomlSourceFromFlagFunc creates a new TOML InputSourceContext from a provided flag name and source context. // NewTomlSourceFromFlagFunc creates a new TOML InputSourceContext from a provided flag name and source context.
func NewTomlSourceFromFlagFunc(flagFileName string) func(context *cli.Context) (InputSourceContext, error) { func NewTomlSourceFromFlagFunc(flagFileName string) func(cCtx *cli.Context) (InputSourceContext, error) {
return func(context *cli.Context) (InputSourceContext, error) { return func(cCtx *cli.Context) (InputSourceContext, error) {
if context.IsSet(flagFileName) { if cCtx.IsSet(flagFileName) {
filePath := context.String(flagFileName) filePath := cCtx.String(flagFileName)
return NewTomlSourceFromFile(filePath) return NewTomlSourceFromFile(filePath)
} }

8
altsrc/yaml_file_loader.go
View File

@ -31,10 +31,10 @@ func NewYamlSourceFromFile(file string) (InputSourceContext, error) {
} }
// NewYamlSourceFromFlagFunc creates a new Yaml InputSourceContext from a provided flag name and source context. // NewYamlSourceFromFlagFunc creates a new Yaml InputSourceContext from a provided flag name and source context.
func NewYamlSourceFromFlagFunc(flagFileName string) func(context *cli.Context) (InputSourceContext, error) { func NewYamlSourceFromFlagFunc(flagFileName string) func(cCtx *cli.Context) (InputSourceContext, error) {
return func(context *cli.Context) (InputSourceContext, error) { return func(cCtx *cli.Context) (InputSourceContext, error) {
if context.IsSet(flagFileName) { if cCtx.IsSet(flagFileName) {
filePath := context.String(flagFileName) filePath := cCtx.String(flagFileName)
return NewYamlSourceFromFile(filePath) return NewYamlSourceFromFile(filePath)
} }

90
app.go
View File

@ -245,48 +245,48 @@ func (a *App) RunContext(ctx context.Context, arguments []string) (err error) {
err = parseIter(set, a, arguments[1:], shellComplete) err = parseIter(set, a, arguments[1:], shellComplete)
nerr := normalizeFlags(a.Flags, set) nerr := normalizeFlags(a.Flags, set)
context := NewContext(a, set, &Context{Context: ctx}) cCtx := NewContext(a, set, &Context{Context: ctx})
if nerr != nil { if nerr != nil {
_, _ = fmt.Fprintln(a.Writer, nerr) _, _ = fmt.Fprintln(a.Writer, nerr)
_ = ShowAppHelp(context) _ = ShowAppHelp(cCtx)
return nerr return nerr
} }
context.shellComplete = shellComplete cCtx.shellComplete = shellComplete
if checkCompletions(context) { if checkCompletions(cCtx) {
return nil return nil
} }
if err != nil { if err != nil {
if a.OnUsageError != nil { if a.OnUsageError != nil {
err := a.OnUsageError(context, err, false) err := a.OnUsageError(cCtx, err, false)
a.handleExitCoder(context, err) a.handleExitCoder(cCtx, err)
return err return err
} }
_, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error()) _, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
_ = ShowAppHelp(context) _ = ShowAppHelp(cCtx)
return err return err
} }
if !a.HideHelp && checkHelp(context) { if !a.HideHelp && checkHelp(cCtx) {
_ = ShowAppHelp(context) _ = ShowAppHelp(cCtx)
return nil return nil
} }
if !a.HideVersion && checkVersion(context) { if !a.HideVersion && checkVersion(cCtx) {
ShowVersion(context) ShowVersion(cCtx)
return nil return nil
} }
cerr := context.checkRequiredFlags(a.Flags) cerr := cCtx.checkRequiredFlags(a.Flags)
if cerr != nil { if cerr != nil {
_ = ShowAppHelp(context) _ = ShowAppHelp(cCtx)
return cerr return cerr
} }
if a.After != nil { if a.After != nil {
defer func() { defer func() {
if afterErr := a.After(context); afterErr != nil { if afterErr := a.After(cCtx); afterErr != nil {
if err != nil { if err != nil {
err = newMultiError(err, afterErr) err = newMultiError(err, afterErr)
} else { } else {
@ -297,20 +297,20 @@ func (a *App) RunContext(ctx context.Context, arguments []string) (err error) {
} }
if a.Before != nil { if a.Before != nil {
beforeErr := a.Before(context) beforeErr := a.Before(cCtx)
if beforeErr != nil { if beforeErr != nil {
a.handleExitCoder(context, beforeErr) a.handleExitCoder(cCtx, beforeErr)
err = beforeErr err = beforeErr
return err return err
} }
} }
args := context.Args() args := cCtx.Args()
if args.Present() { if args.Present() {
name := args.First() name := args.First()
c := a.Command(name) c := a.Command(name)
if c != nil { if c != nil {
return c.Run(context) return c.Run(cCtx)
} }
} }
@ -319,9 +319,9 @@ func (a *App) RunContext(ctx context.Context, arguments []string) (err error) {
} }
// Run default Action // Run default Action
err = a.Action(context) err = a.Action(cCtx)
a.handleExitCoder(context, err) a.handleExitCoder(cCtx, err)
return err return err
} }
@ -359,55 +359,55 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
err = parseIter(set, a, ctx.Args().Tail(), ctx.shellComplete) err = parseIter(set, a, ctx.Args().Tail(), ctx.shellComplete)
nerr := normalizeFlags(a.Flags, set) nerr := normalizeFlags(a.Flags, set)
context := NewContext(a, set, ctx) cCtx := NewContext(a, set, ctx)
if nerr != nil { if nerr != nil {
_, _ = fmt.Fprintln(a.Writer, nerr) _, _ = fmt.Fprintln(a.Writer, nerr)
_, _ = fmt.Fprintln(a.Writer) _, _ = fmt.Fprintln(a.Writer)
if len(a.Commands) > 0 { if len(a.Commands) > 0 {
_ = ShowSubcommandHelp(context) _ = ShowSubcommandHelp(cCtx)
} else { } else {
_ = ShowCommandHelp(ctx, context.Args().First()) _ = ShowCommandHelp(ctx, cCtx.Args().First())
} }
return nerr return nerr
} }
if checkCompletions(context) { if checkCompletions(cCtx) {
return nil return nil
} }
if err != nil { if err != nil {
if a.OnUsageError != nil { if a.OnUsageError != nil {
err = a.OnUsageError(context, err, true) err = a.OnUsageError(cCtx, err, true)
a.handleExitCoder(context, err) a.handleExitCoder(cCtx, err)
return err return err
} }
_, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error()) _, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
_ = ShowSubcommandHelp(context) _ = ShowSubcommandHelp(cCtx)
return err return err
} }
if len(a.Commands) > 0 { if len(a.Commands) > 0 {
if checkSubcommandHelp(context) { if checkSubcommandHelp(cCtx) {
return nil return nil
} }
} else { } else {
if checkCommandHelp(ctx, context.Args().First()) { if checkCommandHelp(ctx, cCtx.Args().First()) {
return nil return nil
} }
} }
cerr := context.checkRequiredFlags(a.Flags) cerr := cCtx.checkRequiredFlags(a.Flags)
if cerr != nil { if cerr != nil {
_ = ShowSubcommandHelp(context) _ = ShowSubcommandHelp(cCtx)
return cerr return cerr
} }
if a.After != nil { if a.After != nil {
defer func() { defer func() {
afterErr := a.After(context) afterErr := a.After(cCtx)
if afterErr != nil { if afterErr != nil {
a.handleExitCoder(context, err) a.handleExitCoder(cCtx, err)
if err != nil { if err != nil {
err = newMultiError(err, afterErr) err = newMultiError(err, afterErr)
} else { } else {
@ -418,27 +418,27 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
} }
if a.Before != nil { if a.Before != nil {
beforeErr := a.Before(context) beforeErr := a.Before(cCtx)
if beforeErr != nil { if beforeErr != nil {
a.handleExitCoder(context, beforeErr) a.handleExitCoder(cCtx, beforeErr)
err = beforeErr err = beforeErr
return err return err
} }
} }
args := context.Args() args := cCtx.Args()
if args.Present() { if args.Present() {
name := args.First() name := args.First()
c := a.Command(name) c := a.Command(name)
if c != nil { if c != nil {
return c.Run(context) return c.Run(cCtx)
} }
} }
// Run default Action // Run default Action
err = a.Action(context) err = a.Action(cCtx)
a.handleExitCoder(context, err) a.handleExitCoder(cCtx, err)
return err return err
} }
@ -498,9 +498,9 @@ func (a *App) appendCommand(c *Command) {
} }
} }
func (a *App) handleExitCoder(context *Context, err error) { func (a *App) handleExitCoder(cCtx *Context, err error) {
if a.ExitErrHandler != nil { if a.ExitErrHandler != nil {
a.ExitErrHandler(context, err) a.ExitErrHandler(cCtx, err)
} else { } else {
HandleExitCoder(err) HandleExitCoder(err)
} }
@ -525,14 +525,14 @@ func (a *Author) String() string {
// HandleAction attempts to figure out which Action signature was used. If // HandleAction attempts to figure out which Action signature was used. If
// it's an ActionFunc or a func with the legacy signature for Action, the func // it's an ActionFunc or a func with the legacy signature for Action, the func
// is run! // is run!
func HandleAction(action interface{}, context *Context) (err error) { func HandleAction(action interface{}, cCtx *Context) (err error) {
switch a := action.(type) { switch a := action.(type) {
case ActionFunc: case ActionFunc:
return a(context) return a(cCtx)
case func(*Context) error: case func(*Context) error:
return a(context) return a(cCtx)
case func(*Context): // deprecated function signature case func(*Context): // deprecated function signature
a(context) a(cCtx)
return nil return nil
} }

8
app_test.go
View File

@ -445,14 +445,14 @@ func TestApp_Setup_defaultsWriter(t *testing.T) {
} }
func TestApp_RunAsSubcommandParseFlags(t *testing.T) { func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
var context *Context var cCtx *Context
a := &App{ a := &App{
Commands: []*Command{ Commands: []*Command{
{ {
Name: "foo", Name: "foo",
Action: func(c *Context) error { Action: func(c *Context) error {
context = c cCtx = c
return nil return nil
}, },
Flags: []Flag{ Flags: []Flag{
@ -468,8 +468,8 @@ func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
} }
_ = a.Run([]string{"", "foo", "--lang", "spanish", "abcd"}) _ = a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
expect(t, context.Args().Get(0), "abcd") expect(t, cCtx.Args().Get(0), "abcd")
expect(t, context.String("lang"), "spanish") expect(t, cCtx.String("lang"), "spanish")
} }
func TestApp_RunAsSubCommandIncorrectUsage(t *testing.T) { func TestApp_RunAsSubCommandIncorrectUsage(t *testing.T) {

36
command.go
View File

@ -105,39 +105,39 @@ func (c *Command) Run(ctx *Context) (err error) {
set, err := c.parseFlags(ctx.Args(), ctx.shellComplete) set, err := c.parseFlags(ctx.Args(), ctx.shellComplete)
context := NewContext(ctx.App, set, ctx) cCtx := NewContext(ctx.App, set, ctx)
context.Command = c cCtx.Command = c
if checkCommandCompletions(context, c.Name) { if checkCommandCompletions(cCtx, c.Name) {
return nil return nil
} }
if err != nil { if err != nil {
if c.OnUsageError != nil { if c.OnUsageError != nil {
err = c.OnUsageError(context, err, false) err = c.OnUsageError(cCtx, err, false)
context.App.handleExitCoder(context, err) cCtx.App.handleExitCoder(cCtx, err)
return err return err
} }
_, _ = fmt.Fprintln(context.App.Writer, "Incorrect Usage:", err.Error()) _, _ = fmt.Fprintln(cCtx.App.Writer, "Incorrect Usage:", err.Error())
_, _ = fmt.Fprintln(context.App.Writer) _, _ = fmt.Fprintln(cCtx.App.Writer)
_ = ShowCommandHelp(context, c.Name) _ = ShowCommandHelp(cCtx, c.Name)
return err return err
} }
if checkCommandHelp(context, c.Name) { if checkCommandHelp(cCtx, c.Name) {
return nil return nil
} }
cerr := context.checkRequiredFlags(c.Flags) cerr := cCtx.checkRequiredFlags(c.Flags)
if cerr != nil { if cerr != nil {
_ = ShowCommandHelp(context, c.Name) _ = ShowCommandHelp(cCtx, c.Name)
return cerr return cerr
} }
if c.After != nil { if c.After != nil {
defer func() { defer func() {
afterErr := c.After(context) afterErr := c.After(cCtx)
if afterErr != nil { if afterErr != nil {
context.App.handleExitCoder(context, err) cCtx.App.handleExitCoder(cCtx, err)
if err != nil { if err != nil {
err = newMultiError(err, afterErr) err = newMultiError(err, afterErr)
} else { } else {
@ -148,9 +148,9 @@ func (c *Command) Run(ctx *Context) (err error) {
} }
if c.Before != nil { if c.Before != nil {
err = c.Before(context) err = c.Before(cCtx)
if err != nil { if err != nil {
context.App.handleExitCoder(context, err) cCtx.App.handleExitCoder(cCtx, err)
return err return err
} }
} }
@ -159,11 +159,11 @@ func (c *Command) Run(ctx *Context) (err error) {
c.Action = helpSubcommand.Action c.Action = helpSubcommand.Action
} }
context.Command = c cCtx.Command = c
err = c.Action(context) err = c.Action(cCtx)
if err != nil { if err != nil {
context.App.handleExitCoder(context, err) cCtx.App.handleExitCoder(cCtx, err)
} }
return err return err
} }

6
command_test.go
View File

@ -30,7 +30,7 @@ func TestCommandFlagParsing(t *testing.T) {
set := flag.NewFlagSet("test", 0) set := flag.NewFlagSet("test", 0)
_ = set.Parse(c.testArgs) _ = set.Parse(c.testArgs)
context := NewContext(app, set, nil) cCtx := NewContext(app, set, nil)
command := Command{ command := Command{
Name: "test-cmd", Name: "test-cmd",
@ -41,10 +41,10 @@ func TestCommandFlagParsing(t *testing.T) {
SkipFlagParsing: c.skipFlagParsing, SkipFlagParsing: c.skipFlagParsing,
} }
err := command.Run(context) err := command.Run(cCtx)
expect(t, err, c.expectedErr) expect(t, err, c.expectedErr)
expect(t, context.Args().Slice(), c.testArgs) expect(t, cCtx.Args().Slice(), c.testArgs)
} }
} }

56
context.go
View File

@ -40,18 +40,18 @@ func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
} }
// NumFlags returns the number of flags set // NumFlags returns the number of flags set
func (c *Context) NumFlags() int { func (cCtx *Context) NumFlags() int {
return c.flagSet.NFlag() return cCtx.flagSet.NFlag()
} }
// Set sets a context flag to a value. // Set sets a context flag to a value.
func (c *Context) Set(name, value string) error { func (cCtx *Context) Set(name, value string) error {
return c.flagSet.Set(name, value) return cCtx.flagSet.Set(name, value)
} }
// IsSet determines if the flag was actually set // IsSet determines if the flag was actually set
func (c *Context) IsSet(name string) bool { func (cCtx *Context) IsSet(name string) bool {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
isSet := false isSet := false
fs.Visit(func(f *flag.Flag) { fs.Visit(func(f *flag.Flag) {
if f.Name == name { if f.Name == name {
@ -62,7 +62,7 @@ func (c *Context) IsSet(name string) bool {
return true return true
} }
f := c.lookupFlag(name) f := cCtx.lookupFlag(name)
if f == nil { if f == nil {
return false return false
} }
@ -74,28 +74,28 @@ func (c *Context) IsSet(name string) bool {
} }
// LocalFlagNames returns a slice of flag names used in this context. // LocalFlagNames returns a slice of flag names used in this context.
func (c *Context) LocalFlagNames() []string { func (cCtx *Context) LocalFlagNames() []string {
var names []string var names []string
c.flagSet.Visit(makeFlagNameVisitor(&names)) cCtx.flagSet.Visit(makeFlagNameVisitor(&names))
return names return names
} }
// FlagNames returns a slice of flag names used by the this context and all of // FlagNames returns a slice of flag names used by the this context and all of
// its parent contexts. // its parent contexts.
func (c *Context) FlagNames() []string { func (cCtx *Context) FlagNames() []string {
var names []string var names []string
for _, ctx := range c.Lineage() { for _, pCtx := range cCtx.Lineage() {
ctx.flagSet.Visit(makeFlagNameVisitor(&names)) pCtx.flagSet.Visit(makeFlagNameVisitor(&names))
} }
return names return names
} }
// Lineage returns *this* context and all of its ancestor contexts in order from // Lineage returns *this* context and all of its ancestor contexts in order from
// child to parent // child to parent
func (c *Context) Lineage() []*Context { func (cCtx *Context) Lineage() []*Context {
var lineage []*Context var lineage []*Context
for cur := c; cur != nil; cur = cur.parentContext { for cur := cCtx; cur != nil; cur = cur.parentContext {
lineage = append(lineage, cur) lineage = append(lineage, cur)
} }
@ -103,26 +103,26 @@ func (c *Context) Lineage() []*Context {
} }
// Value returns the value of the flag corresponding to `name` // Value returns the value of the flag corresponding to `name`
func (c *Context) Value(name string) interface{} { func (cCtx *Context) Value(name string) interface{} {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return fs.Lookup(name).Value.(flag.Getter).Get() return fs.Lookup(name).Value.(flag.Getter).Get()
} }
return nil return nil
} }
// Args returns the command line arguments associated with the context. // Args returns the command line arguments associated with the context.
func (c *Context) Args() Args { func (cCtx *Context) Args() Args {
ret := args(c.flagSet.Args()) ret := args(cCtx.flagSet.Args())
return &ret return &ret
} }
// NArg returns the number of the command line arguments. // NArg returns the number of the command line arguments.
func (c *Context) NArg() int { func (cCtx *Context) NArg() int {
return c.Args().Len() return cCtx.Args().Len()
} }
func (ctx *Context) lookupFlag(name string) Flag { func (cCtx *Context) lookupFlag(name string) Flag {
for _, c := range ctx.Lineage() { for _, c := range cCtx.Lineage() {
if c.Command == nil { if c.Command == nil {
continue continue
} }
@ -136,8 +136,8 @@ func (ctx *Context) lookupFlag(name string) Flag {
} }
} }
if ctx.App != nil { if cCtx.App != nil {
for _, f := range ctx.App.Flags { for _, f := range cCtx.App.Flags {
for _, n := range f.Names() { for _, n := range f.Names() {
if n == name { if n == name {
return f return f
@ -149,8 +149,8 @@ func (ctx *Context) lookupFlag(name string) Flag {
return nil return nil
} }
func (ctx *Context) lookupFlagSet(name string) *flag.FlagSet { func (cCtx *Context) lookupFlagSet(name string) *flag.FlagSet {
for _, c := range ctx.Lineage() { for _, c := range cCtx.Lineage() {
if c.flagSet == nil { if c.flagSet == nil {
continue continue
} }
@ -162,7 +162,7 @@ func (ctx *Context) lookupFlagSet(name string) *flag.FlagSet {
return nil return nil
} }
func (context *Context) checkRequiredFlags(flags []Flag) requiredFlagsErr { func (cCtx *Context) checkRequiredFlags(flags []Flag) requiredFlagsErr {
var missingFlags []string var missingFlags []string
for _, f := range flags { for _, f := range flags {
if rf, ok := f.(RequiredFlag); ok && rf.IsRequired() { if rf, ok := f.(RequiredFlag); ok && rf.IsRequired() {
@ -174,7 +174,7 @@ func (context *Context) checkRequiredFlags(flags []Flag) requiredFlagsErr {
flagName = key flagName = key
} }
if context.IsSet(strings.TrimSpace(key)) { if cCtx.IsSet(strings.TrimSpace(key)) {
flagPresent = true flagPresent = true
} }
} }

4
flag_bool.go
View File

@ -104,8 +104,8 @@ func (f *BoolFlag) Apply(set *flag.FlagSet) error {
// Bool looks up the value of a local BoolFlag, returns // Bool looks up the value of a local BoolFlag, returns
// false if not found // false if not found
func (c *Context) Bool(name string) bool { func (cCtx *Context) Bool(name string) bool {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupBool(name, fs) return lookupBool(name, fs)
} }
return false return false

4
flag_duration.go
View File

@ -103,8 +103,8 @@ func (f *DurationFlag) Apply(set *flag.FlagSet) error {
// Duration looks up the value of a local DurationFlag, returns // Duration looks up the value of a local DurationFlag, returns
// 0 if not found // 0 if not found
func (c *Context) Duration(name string) time.Duration { func (cCtx *Context) Duration(name string) time.Duration {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupDuration(name, fs) return lookupDuration(name, fs)
} }
return 0 return 0

4
flag_float64.go
View File

@ -103,8 +103,8 @@ func (f *Float64Flag) Apply(set *flag.FlagSet) error {
// Float64 looks up the value of a local Float64Flag, returns // Float64 looks up the value of a local Float64Flag, returns
// 0 if not found // 0 if not found
func (c *Context) Float64(name string) float64 { func (cCtx *Context) Float64(name string) float64 {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupFloat64(name, fs) return lookupFloat64(name, fs)
} }
return 0 return 0

4
flag_float64_slice.go
View File

@ -177,8 +177,8 @@ func (f *Float64SliceFlag) Apply(set *flag.FlagSet) error {
// Float64Slice looks up the value of a local Float64SliceFlag, returns // Float64Slice looks up the value of a local Float64SliceFlag, returns
// nil if not found // nil if not found
func (c *Context) Float64Slice(name string) []float64 { func (cCtx *Context) Float64Slice(name string) []float64 {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupFloat64Slice(name, fs) return lookupFloat64Slice(name, fs)
} }
return nil return nil

4
flag_generic.go
View File

@ -106,8 +106,8 @@ func (f GenericFlag) Apply(set *flag.FlagSet) error {
// Generic looks up the value of a local GenericFlag, returns // Generic looks up the value of a local GenericFlag, returns
// nil if not found // nil if not found
func (c *Context) Generic(name string) interface{} { func (cCtx *Context) Generic(name string) interface{} {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupGeneric(name, fs) return lookupGeneric(name, fs)
} }
return nil return nil

4
flag_int.go
View File

@ -104,8 +104,8 @@ func (f *IntFlag) Apply(set *flag.FlagSet) error {
// Int looks up the value of a local IntFlag, returns // Int looks up the value of a local IntFlag, returns
// 0 if not found // 0 if not found
func (c *Context) Int(name string) int { func (cCtx *Context) Int(name string) int {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupInt(name, fs) return lookupInt(name, fs)
} }
return 0 return 0

4
flag_int64.go
View File

@ -103,8 +103,8 @@ func (f *Int64Flag) Apply(set *flag.FlagSet) error {
// Int64 looks up the value of a local Int64Flag, returns // Int64 looks up the value of a local Int64Flag, returns
// 0 if not found // 0 if not found
func (c *Context) Int64(name string) int64 { func (cCtx *Context) Int64(name string) int64 {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupInt64(name, fs) return lookupInt64(name, fs)
} }
return 0 return 0

4
flag_int64_slice.go
View File

@ -176,8 +176,8 @@ func (f *Int64SliceFlag) Apply(set *flag.FlagSet) error {
// Int64Slice looks up the value of a local Int64SliceFlag, returns // Int64Slice looks up the value of a local Int64SliceFlag, returns
// nil if not found // nil if not found
func (c *Context) Int64Slice(name string) []int64 { func (cCtx *Context) Int64Slice(name string) []int64 {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupInt64Slice(name, fs) return lookupInt64Slice(name, fs)
} }
return nil return nil

4
flag_int_slice.go
View File

@ -187,8 +187,8 @@ func (f *IntSliceFlag) Apply(set *flag.FlagSet) error {
// IntSlice looks up the value of a local IntSliceFlag, returns // IntSlice looks up the value of a local IntSliceFlag, returns
// nil if not found // nil if not found
func (c *Context) IntSlice(name string) []int { func (cCtx *Context) IntSlice(name string) []int {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupIntSlice(name, fs) return lookupIntSlice(name, fs)
} }
return nil return nil

4
flag_path.go
View File

@ -98,8 +98,8 @@ func (f *PathFlag) Apply(set *flag.FlagSet) error {
// Path looks up the value of a local PathFlag, returns // Path looks up the value of a local PathFlag, returns
// "" if not found // "" if not found
func (c *Context) Path(name string) string { func (cCtx *Context) Path(name string) string {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupPath(name, fs) return lookupPath(name, fs)
} }

4
flag_string.go
View File

@ -99,8 +99,8 @@ func (f *StringFlag) Apply(set *flag.FlagSet) error {
// String looks up the value of a local StringFlag, returns // String looks up the value of a local StringFlag, returns
// "" if not found // "" if not found
func (c *Context) String(name string) string { func (cCtx *Context) String(name string) string {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupString(name, fs) return lookupString(name, fs)
} }
return "" return ""

4
flag_string_slice.go
View File

@ -188,8 +188,8 @@ func (f *StringSliceFlag) Apply(set *flag.FlagSet) error {
// StringSlice looks up the value of a local StringSliceFlag, returns // StringSlice looks up the value of a local StringSliceFlag, returns
// nil if not found // nil if not found
func (c *Context) StringSlice(name string) []string { func (cCtx *Context) StringSlice(name string) []string {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupStringSlice(name, fs) return lookupStringSlice(name, fs)
} }
return nil return nil

4
flag_timestamp.go
View File

@ -165,8 +165,8 @@ func (f *TimestampFlag) Apply(set *flag.FlagSet) error {
} }
// Timestamp gets the timestamp from a flag name // Timestamp gets the timestamp from a flag name
func (c *Context) Timestamp(name string) *time.Time { func (cCtx *Context) Timestamp(name string) *time.Time {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupTimestamp(name, fs) return lookupTimestamp(name, fs)
} }
return nil return nil

4
flag_uint.go
View File

@ -103,8 +103,8 @@ func (f *UintFlag) GetEnvVars() []string {
// Uint looks up the value of a local UintFlag, returns // Uint looks up the value of a local UintFlag, returns
// 0 if not found // 0 if not found
func (c *Context) Uint(name string) uint { func (cCtx *Context) Uint(name string) uint {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupUint(name, fs) return lookupUint(name, fs)
} }
return 0 return 0

4
flag_uint64.go
View File

@ -103,8 +103,8 @@ func (f *Uint64Flag) GetEnvVars() []string {
// Uint64 looks up the value of a local Uint64Flag, returns // Uint64 looks up the value of a local Uint64Flag, returns
// 0 if not found // 0 if not found
func (c *Context) Uint64(name string) uint64 { func (cCtx *Context) Uint64(name string) uint64 {
if fs := c.lookupFlagSet(name); fs != nil { if fs := cCtx.lookupFlagSet(name); fs != nil {
return lookupUint64(name, fs) return lookupUint64(name, fs)
} }
return 0 return 0

4
funcs.go
View File

@ -21,11 +21,11 @@ type CommandNotFoundFunc func(*Context, string)
// customized usage error messages. This function is able to replace the // customized usage error messages. This function is able to replace the
// original error messages. If this function is not set, the "Incorrect usage" // original error messages. If this function is not set, the "Incorrect usage"
// is displayed and the execution is interrupted. // is displayed and the execution is interrupted.
type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error type OnUsageErrorFunc func(cCtx *Context, err error, isSubcommand bool) error
// ExitErrHandlerFunc is executed if provided in order to handle exitError values // ExitErrHandlerFunc is executed if provided in order to handle exitError values
// returned by Actions and Before/After functions. // returned by Actions and Before/After functions.
type ExitErrHandlerFunc func(context *Context, err error) type ExitErrHandlerFunc func(cCtx *Context, err error)
// FlagStringFunc is used by the help generation to display a flag, which is // FlagStringFunc is used by the help generation to display a flag, which is
// expected to be a single line. // expected to be a single line.

92
help.go
View File

@ -15,13 +15,13 @@ var helpCommand = &Command{
Aliases: []string{"h"}, Aliases: []string{"h"},
Usage: "Shows a list of commands or help for one command", Usage: "Shows a list of commands or help for one command",
ArgsUsage: "[command]", ArgsUsage: "[command]",
Action: func(c *Context) error { Action: func(cCtx *Context) error {
args := c.Args() args := cCtx.Args()
if args.Present() { if args.Present() {
return ShowCommandHelp(c, args.First()) return ShowCommandHelp(cCtx, args.First())
} }
_ = ShowAppHelp(c) _ = ShowAppHelp(cCtx)
return nil return nil
}, },
} }
@ -31,13 +31,13 @@ var helpSubcommand = &Command{
Aliases: []string{"h"}, Aliases: []string{"h"},
Usage: "Shows a list of commands or help for one command", Usage: "Shows a list of commands or help for one command",
ArgsUsage: "[command]", ArgsUsage: "[command]",
Action: func(c *Context) error { Action: func(cCtx *Context) error {
args := c.Args() args := cCtx.Args()
if args.Present() { if args.Present() {
return ShowCommandHelp(c, args.First()) return ShowCommandHelp(cCtx, args.First())
} }
return ShowSubcommandHelp(c) return ShowSubcommandHelp(cCtx)
}, },
} }
@ -71,30 +71,30 @@ func ShowAppHelpAndExit(c *Context, exitCode int) {
} }
// ShowAppHelp is an action that displays the help. // ShowAppHelp is an action that displays the help.
func ShowAppHelp(c *Context) error { func ShowAppHelp(cCtx *Context) error {
tpl := c.App.CustomAppHelpTemplate tpl := cCtx.App.CustomAppHelpTemplate
if tpl == "" { if tpl == "" {
tpl = AppHelpTemplate tpl = AppHelpTemplate
} }
if c.App.ExtraInfo == nil { if cCtx.App.ExtraInfo == nil {
HelpPrinter(c.App.Writer, tpl, c.App) HelpPrinter(cCtx.App.Writer, tpl, cCtx.App)
return nil return nil
} }
customAppData := func() map[string]interface{} { customAppData := func() map[string]interface{} {
return map[string]interface{}{ return map[string]interface{}{
"ExtraInfo": c.App.ExtraInfo, "ExtraInfo": cCtx.App.ExtraInfo,
} }
} }
HelpPrinterCustom(c.App.Writer, tpl, c.App, customAppData()) HelpPrinterCustom(cCtx.App.Writer, tpl, cCtx.App, customAppData())
return nil return nil
} }
// DefaultAppComplete prints the list of subcommands as the default app completion method // DefaultAppComplete prints the list of subcommands as the default app completion method
func DefaultAppComplete(c *Context) { func DefaultAppComplete(cCtx *Context) {
DefaultCompleteWithFlags(nil)(c) DefaultCompleteWithFlags(nil)(cCtx)
} }
func printCommandSuggestions(commands []*Command, writer io.Writer) { func printCommandSuggestions(commands []*Command, writer io.Writer) {
@ -159,30 +159,30 @@ func printFlagSuggestions(lastArg string, flags []Flag, writer io.Writer) {
} }
} }
func DefaultCompleteWithFlags(cmd *Command) func(c *Context) { func DefaultCompleteWithFlags(cmd *Command) func(cCtx *Context) {
return func(c *Context) { return func(cCtx *Context) {
if len(os.Args) > 2 { if len(os.Args) > 2 {
lastArg := os.Args[len(os.Args)-2] lastArg := os.Args[len(os.Args)-2]
if strings.HasPrefix(lastArg, "-") { if strings.HasPrefix(lastArg, "-") {
if cmd != nil { if cmd != nil {
printFlagSuggestions(lastArg, cmd.Flags, c.App.Writer) printFlagSuggestions(lastArg, cmd.Flags, cCtx.App.Writer)
return return
} }
printFlagSuggestions(lastArg, c.App.Flags, c.App.Writer) printFlagSuggestions(lastArg, cCtx.App.Flags, cCtx.App.Writer)
return return
} }
} }
if cmd != nil { if cmd != nil {
printCommandSuggestions(cmd.Subcommands, c.App.Writer) printCommandSuggestions(cmd.Subcommands, cCtx.App.Writer)
return return
} }
printCommandSuggestions(c.App.Commands, c.App.Writer) printCommandSuggestions(cCtx.App.Commands, cCtx.App.Writer)
} }
} }
@ -228,32 +228,32 @@ func ShowSubcommandHelpAndExit(c *Context, exitCode int) {
} }
// ShowSubcommandHelp prints help for the given subcommand // ShowSubcommandHelp prints help for the given subcommand
func ShowSubcommandHelp(c *Context) error { func ShowSubcommandHelp(cCtx *Context) error {
if c == nil { if cCtx == nil {
return nil return nil
} }
if c.Command != nil { if cCtx.Command != nil {
return ShowCommandHelp(c, c.Command.Name) return ShowCommandHelp(cCtx, cCtx.Command.Name)
} }
return ShowCommandHelp(c, "") return ShowCommandHelp(cCtx, "")
} }
// ShowVersion prints the version number of the App // ShowVersion prints the version number of the App
func ShowVersion(c *Context) { func ShowVersion(cCtx *Context) {
VersionPrinter(c) VersionPrinter(cCtx)
} }
func printVersion(c *Context) { func printVersion(cCtx *Context) {
_, _ = fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version) _, _ = fmt.Fprintf(cCtx.App.Writer, "%v version %v\n", cCtx.App.Name, cCtx.App.Version)
} }
// ShowCompletions prints the lists of commands within a given context // ShowCompletions prints the lists of commands within a given context
func ShowCompletions(c *Context) { func ShowCompletions(cCtx *Context) {
a := c.App a := cCtx.App
if a != nil && a.BashComplete != nil { if a != nil && a.BashComplete != nil {
a.BashComplete(c) a.BashComplete(cCtx)
} }
} }
@ -304,20 +304,20 @@ func printHelp(out io.Writer, templ string, data interface{}) {
HelpPrinterCustom(out, templ, data, nil) HelpPrinterCustom(out, templ, data, nil)
} }
func checkVersion(c *Context) bool { func checkVersion(cCtx *Context) bool {
found := false found := false
for _, name := range VersionFlag.Names() { for _, name := range VersionFlag.Names() {
if c.Bool(name) { if cCtx.Bool(name) {
found = true found = true
} }
} }
return found return found
} }
func checkHelp(c *Context) bool { func checkHelp(cCtx *Context) bool {
found := false found := false
for _, name := range HelpFlag.Names() { for _, name := range HelpFlag.Names() {
if c.Bool(name) { if cCtx.Bool(name) {
found = true found = true
} }
} }
@ -333,9 +333,9 @@ func checkCommandHelp(c *Context, name string) bool {
return false return false
} }
func checkSubcommandHelp(c *Context) bool { func checkSubcommandHelp(cCtx *Context) bool {
if c.Bool("h") || c.Bool("help") { if cCtx.Bool("h") || cCtx.Bool("help") {
_ = ShowSubcommandHelp(c) _ = ShowSubcommandHelp(cCtx)
return true return true
} }
@ -357,20 +357,20 @@ func checkShellCompleteFlag(a *App, arguments []string) (bool, []string) {
return true, arguments[:pos] return true, arguments[:pos]
} }
func checkCompletions(c *Context) bool { func checkCompletions(cCtx *Context) bool {
if !c.shellComplete { if !cCtx.shellComplete {
return false return false
} }
if args := c.Args(); args.Present() { if args := cCtx.Args(); args.Present() {
name := args.First() name := args.First()
if cmd := c.App.Command(name); cmd != nil { if cmd := cCtx.App.Command(name); cmd != nil {
// let the command handle the completion // let the command handle the completion
return false return false
} }
} }
ShowCompletions(c) ShowCompletions(cCtx)
return true return true
} }