Repository navigation
Expand file tree
/
Copy pathcommand.go
More file actions
415 lines (357 loc) · 10.3 KB
/
Copy pathcommand.go
File metadata and controls
415 lines (357 loc) · 10.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
package cli
import (
"fmt"
"io/ioutil"
"slices"
"sort"
"strings"
"github.com/posener/complete"
)
// Command is a subcommand for a cli.App.
type Command struct {
// The name of the command
Name string
// short name of the command. Typically one character (deprecated, use `Aliases`)
ShortName string
// A list of aliases for the command
Aliases []string
// A short description of the usage of this command
Usage string
// Custom text to show on USAGE section of help
UsageText string
// A longer explanation of how the command works
Description string
// A short description of the arguments of this command
ArgsUsage string
// The category the command is part of
Category string
// Completer predicts this command's positional arguments during shell
// completion.
Completer complete.Predictor
// An action to execute before any sub-subcommands are run, but after the context is ready
// If a non-nil error is returned, no sub-subcommands are run
Before BeforeFunc
// An action to execute after any subcommands are run, but after the subcommand has finished
// It is run even if Action() panics
After AfterFunc
// The function to call when this command is invoked
Action ActionFunc
// Execute this function if a usage error occurs.
OnUsageError OnUsageErrorFunc
// List of child commands
Subcommands Commands
// List of flags to parse
Flags []Flag
// Treat all flags as normal arguments if true
SkipFlagParsing bool
// Skip argument reordering which attempts to move flags before arguments,
// but only works if all flags appear after all arguments. This behavior was
// removed n version 2 since it only works under specific conditions so we
// backport here by exposing it as an option for compatibility.
SkipArgReorder bool
// Boolean to hide built-in help flag
HideHelp bool
// Boolean to hide built-in help command
HideHelpCommand bool
// Boolean to hide this command from help or completion
Hidden bool
// Boolean to hide aliases for this command from help or completion
HiddenAliases bool
// Full name of command for help, defaults to full command name, including parent commands.
HelpName string
commandNamePath []string
// app-wide GlobalFlags, populated at help-render time
globalFlags []Flag
// Default prompt, specific to OS
Prompt string
// Command to set the environment variable, specific to OS
EnvVarSetCommand string
// Assignment operator to set the environment variable, specific to OS
AssignmentOperator string
// Disable history for security reasons
DisableHistory string
// Enable history
EnableHistory string
// CustomHelpTemplate the text template for the command help topic.
// cli.go uses text/template to render templates. You can
// render custom help text by setting this variable.
CustomHelpTemplate string
}
type CommandsByName []Command
func (c CommandsByName) Len() int {
return len(c)
}
func (c CommandsByName) Less(i, j int) bool {
return c[i].Name < c[j].Name
}
func (c CommandsByName) Swap(i, j int) {
c[i], c[j] = c[j], c[i]
}
// FullName returns the full name of the command.
// For subcommands this ensures that parent commands are part of the command path
func (c Command) FullName() string {
if c.commandNamePath == nil {
return c.Name
}
return strings.Join(c.commandNamePath, " ")
}
// Commands is a slice of Command
type Commands []Command
type isBoolFlag interface {
IsBoolFlag() bool
}
// Run invokes the command given the context, parses ctx.Args() to generate command-specific flags
func (c Command) Run(ctx *Context) (err error) {
if len(c.Subcommands) > 0 {
return c.startApp(ctx)
}
flags := c.resolveFlags(ctx)
set, err := flagSet(c.Name, flags)
if err != nil {
return err
}
set.SetOutput(ioutil.Discard)
if c.SkipFlagParsing {
err = set.Parse(append([]string{"--"}, ctx.Args().Tail()...))
} else if !c.SkipArgReorder {
var (
regularArgs, flagArgs []string
terminatorIndex = -1
isFlagArg bool
)
for index, arg := range ctx.Args().Tail() {
doubleHyphen := false
switch {
case terminatorIndex > -1:
regularArgs = append(regularArgs, arg)
case isFlagArg:
flagArgs = append(flagArgs, arg)
isFlagArg = false
case arg == "--":
terminatorIndex = index
regularArgs = append(regularArgs, arg)
case arg == "-":
regularArgs = append(regularArgs, arg)
case strings.HasPrefix(arg, "--"):
doubleHyphen = true
fallthrough
case strings.HasPrefix(arg, "-"):
flagArgs = append(flagArgs, arg)
if eq := strings.Index(arg, "="); eq > -1 {
break
}
hyphens := "-"
if doubleHyphen {
hyphens += "-"
}
flagName := strings.TrimPrefix(arg, hyphens)
f := set.Lookup(flagName)
if f != nil {
fv, ok := f.Value.(isBoolFlag)
isFlagArg = !ok || !fv.IsBoolFlag()
}
default:
regularArgs = append(regularArgs, arg)
}
}
err = set.Parse(append(flagArgs, regularArgs...))
} else {
err = set.Parse(ctx.Args().Tail())
}
nerr := normalizeFlags(flags, set)
if nerr != nil {
fmt.Fprintln(ctx.App.Writer, nerr)
fmt.Fprintln(ctx.App.Writer)
return nerr
}
context := NewContext(ctx.App, set, ctx)
context.Command = c
if err != nil {
if onUsageError := c.resolveOnUsageError(context); onUsageError != nil {
err := onUsageError(context, err, false)
HandleExitCoder(err)
return err
}
fmt.Fprintln(context.App.Writer, "Incorrect Usage:", err.Error())
fmt.Fprintln(context.App.Writer)
return err
}
if checkCommandHelp(context, c.Name) {
return nil
}
if after := c.resolveAfter(context); after != nil {
defer func() {
afterErr := after(context)
if afterErr != nil {
HandleExitCoder(err)
if err != nil {
err = NewMultiError(err, afterErr)
} else {
err = afterErr
}
}
}()
}
if before := c.resolveBefore(context); before != nil {
err = before(context)
if err != nil {
fmt.Fprintln(context.App.Writer, err)
fmt.Fprintln(context.App.Writer)
HandleExitCoder(err)
return err
}
}
c.Action = c.resolveAction(context)
err = c.Action(context)
if err != nil {
HandleExitCoder(err)
}
return err
}
// Names returns the names including short names and aliases.
func (c Command) Names() []string {
names := []string{c.Name}
if c.ShortName != "" {
names = append(names, c.ShortName)
}
if !c.HiddenAliases {
names = append(names, c.Aliases...)
}
return names
}
// NamesWithHiddenAliases returns the names including short names and aliases.
func (c Command) NamesWithHiddenAliases() []string {
names := []string{c.Name}
if c.ShortName != "" {
names = append(names, c.ShortName)
}
names = append(names, c.Aliases...)
return names
}
// HasName returns true if Command.Name or Command.ShortName matches given name
func (c Command) HasName(name string) bool {
for _, n := range c.NamesWithHiddenAliases() {
if n == name {
return true
}
}
return false
}
func (c Command) startApp(ctx *Context) error {
app := NewApp()
app.Metadata = ctx.App.Metadata
// set the name and usage
app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
if c.HelpName == "" {
app.HelpName = c.HelpName
} else {
app.HelpName = app.Name
}
app.Usage = c.Usage
app.Description = c.Description
app.ArgsUsage = c.ArgsUsage
// set CommandNotFound
app.CommandNotFound = ctx.App.CommandNotFound
app.CustomAppHelpTemplate = c.CustomHelpTemplate
// set the flags and commands
app.Commands = c.Subcommands
app.Flags = c.Flags
app.HideHelp = c.hideHelp(ctx)
app.HideHelpCommand = c.hideHelpCommand(ctx)
// propagate the app-wide globals so nested commands inherit them
app.DefaultBefore = ctx.App.DefaultBefore
app.DefaultAction = ctx.App.DefaultAction
app.DefaultAfter = ctx.App.DefaultAfter
app.DefaultOnUsageError = ctx.App.DefaultOnUsageError
app.GlobalHideHelp = ctx.App.GlobalHideHelp
app.GlobalHideHelpCommand = ctx.App.GlobalHideHelpCommand
app.GlobalFlags = ctx.App.GlobalFlags
app.Version = ctx.App.Version
app.HideVersion = ctx.App.HideVersion
app.Compiled = ctx.App.Compiled
app.Author = ctx.App.Author
app.Email = ctx.App.Email
app.Writer = ctx.App.Writer
app.HelpWriter = ctx.App.HelpWriter
app.ErrWriter = ctx.App.ErrWriter
app.categories = CommandCategories{}
for _, command := range c.Subcommands {
app.categories = app.categories.AddCommand(command.Category, command)
}
sort.Sort(app.categories)
// set the actions
app.Before = c.resolveBefore(ctx)
app.After = c.resolveAfter(ctx)
app.OnUsageError = c.resolveOnUsageError(ctx)
app.Action = c.resolveAction(ctx)
for index, cc := range app.Commands {
app.Commands[index].commandNamePath = []string{c.Name, cc.Name}
}
return app.RunAsSubcommand(ctx)
}
func (c Command) hideHelp(ctx *Context) bool {
return ctx.App.GlobalHideHelp || c.HideHelp
}
func (c Command) hideHelpCommand(ctx *Context) bool {
return ctx.App.GlobalHideHelpCommand || c.HideHelpCommand
}
func (c Command) resolveBefore(ctx *Context) BeforeFunc {
if c.Before != nil {
return c.Before
}
return ctx.App.DefaultBefore
}
func (c Command) resolveAfter(ctx *Context) AfterFunc {
if c.After != nil {
return c.After
}
return ctx.App.DefaultAfter
}
func (c Command) resolveOnUsageError(ctx *Context) OnUsageErrorFunc {
if c.OnUsageError != nil {
return c.OnUsageError
}
return ctx.App.DefaultOnUsageError
}
func (c Command) resolveAction(ctx *Context) ActionFunc {
if c.Action != nil {
return c.Action
}
if ctx.App.DefaultAction != nil {
return ctx.App.DefaultAction
}
return helpSubcommand.Action
}
func (c Command) resolveFlags(ctx *Context) []Flag {
flags := slices.Concat(c.Flags, ctx.App.GlobalFlags)
if !c.hideHelp(ctx) && (HelpFlag != BoolFlag{}) {
// append help to flags
flags = append(flags, HelpFlag)
}
return flags
}
// VisibleFlags returns a slice of the Flags with Hidden=false
func (c Command) VisibleFlags() []Flag {
flags := slices.Concat(c.Flags, c.globalFlags)
if !c.HideHelp && (HelpFlag != BoolFlag{}) {
// append help to flags
flags = append(flags, HelpFlag)
}
return visibleFlags(flags)
}
// VisibleLocalFlags returns a slice of the non-global Flags with Hidden=false
func (c Command) VisibleLocalFlags() []Flag {
flags := c.Flags
if !c.HideHelp && (HelpFlag != BoolFlag{}) {
// append help to flags
flags = append(
flags,
HelpFlag,
)
}
return visibleFlags(flags)
}
// VisibleGlobalFlags returns a slice of the global Flags with Hidden=false
func (c Command) VisibleGlobalFlags() []Flag {
return visibleFlags(c.globalFlags)
}