Bo-Yi Wu
7 years ago
23 changed files with 5789 additions and 0 deletions
@ -0,0 +1,47 @@ |
|||
workspace: |
|||
base: /go/src |
|||
path: github.com/appleboy/drone-packer |
|||
|
|||
clone: |
|||
git: |
|||
image: plugins/git |
|||
depth: 50 |
|||
tags: true |
|||
|
|||
pipeline: |
|||
lint: |
|||
image: golang:1.10 |
|||
pull: true |
|||
commands: |
|||
- make vet |
|||
- make lint |
|||
- make test-vendor |
|||
- make misspell-check |
|||
|
|||
build_linux_amd64: |
|||
image: golang:1.10 |
|||
pull: true |
|||
group: build |
|||
commands: |
|||
- make build_linux_amd64 |
|||
|
|||
build_linux_i386: |
|||
image: golang:1.10 |
|||
pull: true |
|||
group: build |
|||
commands: |
|||
- make build_linux_i386 |
|||
|
|||
build_linux_arm64: |
|||
image: golang:1.10 |
|||
pull: true |
|||
group: build |
|||
commands: |
|||
- make build_linux_arm64 |
|||
|
|||
build_linux_arm: |
|||
image: golang:1.10 |
|||
pull: true |
|||
group: build |
|||
commands: |
|||
- make build_linux_arm |
|||
@ -0,0 +1,435 @@ |
|||
# Change Log |
|||
|
|||
**ATTN**: This project uses [semantic versioning](http://semver.org/). |
|||
|
|||
## [Unreleased] |
|||
|
|||
## 1.20.0 - 2017-08-10 |
|||
|
|||
### Fixed |
|||
|
|||
* `HandleExitCoder` is now correctly iterates over all errors in |
|||
a `MultiError`. The exit code is the exit code of the last error or `1` if |
|||
there are no `ExitCoder`s in the `MultiError`. |
|||
* Fixed YAML file loading on Windows (previously would fail validate the file path) |
|||
* Subcommand `Usage`, `Description`, `ArgsUsage`, `OnUsageError` correctly |
|||
propogated |
|||
* `ErrWriter` is now passed downwards through command structure to avoid the |
|||
need to redefine it |
|||
* Pass `Command` context into `OnUsageError` rather than parent context so that |
|||
all fields are avaiable |
|||
* Errors occuring in `Before` funcs are no longer double printed |
|||
* Use `UsageText` in the help templates for commands and subcommands if |
|||
defined; otherwise build the usage as before (was previously ignoring this |
|||
field) |
|||
* `IsSet` and `GlobalIsSet` now correctly return whether a flag is set if |
|||
a program calls `Set` or `GlobalSet` directly after flag parsing (would |
|||
previously only return `true` if the flag was set during parsing) |
|||
|
|||
### Changed |
|||
|
|||
* No longer exit the program on command/subcommand error if the error raised is |
|||
not an `OsExiter`. This exiting behavior was introduced in 1.19.0, but was |
|||
determined to be a regression in functionality. See [the |
|||
PR](https://github.com/urfave/cli/pull/595) for discussion. |
|||
|
|||
### Added |
|||
|
|||
* `CommandsByName` type was added to make it easy to sort `Command`s by name, |
|||
alphabetically |
|||
* `altsrc` now handles loading of string and int arrays from TOML |
|||
* Support for definition of custom help templates for `App` via |
|||
`CustomAppHelpTemplate` |
|||
* Support for arbitrary key/value fields on `App` to be used with |
|||
`CustomAppHelpTemplate` via `ExtraInfo` |
|||
* `HelpFlag`, `VersionFlag`, and `BashCompletionFlag` changed to explictly be |
|||
`cli.Flag`s allowing for the use of custom flags satisfying the `cli.Flag` |
|||
interface to be used. |
|||
|
|||
|
|||
## [1.19.1] - 2016-11-21 |
|||
|
|||
### Fixed |
|||
|
|||
- Fixes regression introduced in 1.19.0 where using an `ActionFunc` as |
|||
the `Action` for a command would cause it to error rather than calling the |
|||
function. Should not have a affected declarative cases using `func(c |
|||
*cli.Context) err)`. |
|||
- Shell completion now handles the case where the user specifies |
|||
`--generate-bash-completion` immediately after a flag that takes an argument. |
|||
Previously it call the application with `--generate-bash-completion` as the |
|||
flag value. |
|||
|
|||
## [1.19.0] - 2016-11-19 |
|||
### Added |
|||
- `FlagsByName` was added to make it easy to sort flags (e.g. `sort.Sort(cli.FlagsByName(app.Flags))`) |
|||
- A `Description` field was added to `App` for a more detailed description of |
|||
the application (similar to the existing `Description` field on `Command`) |
|||
- Flag type code generation via `go generate` |
|||
- Write to stderr and exit 1 if action returns non-nil error |
|||
- Added support for TOML to the `altsrc` loader |
|||
- `SkipArgReorder` was added to allow users to skip the argument reordering. |
|||
This is useful if you want to consider all "flags" after an argument as |
|||
arguments rather than flags (the default behavior of the stdlib `flag` |
|||
library). This is backported functionality from the [removal of the flag |
|||
reordering](https://github.com/urfave/cli/pull/398) in the unreleased version |
|||
2 |
|||
- For formatted errors (those implementing `ErrorFormatter`), the errors will |
|||
be formatted during output. Compatible with `pkg/errors`. |
|||
|
|||
### Changed |
|||
- Raise minimum tested/supported Go version to 1.2+ |
|||
|
|||
### Fixed |
|||
- Consider empty environment variables as set (previously environment variables |
|||
with the equivalent of `""` would be skipped rather than their value used). |
|||
- Return an error if the value in a given environment variable cannot be parsed |
|||
as the flag type. Previously these errors were silently swallowed. |
|||
- Print full error when an invalid flag is specified (which includes the invalid flag) |
|||
- `App.Writer` defaults to `stdout` when `nil` |
|||
- If no action is specified on a command or app, the help is now printed instead of `panic`ing |
|||
- `App.Metadata` is initialized automatically now (previously was `nil` unless initialized) |
|||
- Correctly show help message if `-h` is provided to a subcommand |
|||
- `context.(Global)IsSet` now respects environment variables. Previously it |
|||
would return `false` if a flag was specified in the environment rather than |
|||
as an argument |
|||
- Removed deprecation warnings to STDERR to avoid them leaking to the end-user |
|||
- `altsrc`s import paths were updated to use `gopkg.in/urfave/cli.v1`. This |
|||
fixes issues that occurred when `gopkg.in/urfave/cli.v1` was imported as well |
|||
as `altsrc` where Go would complain that the types didn't match |
|||
|
|||
## [1.18.1] - 2016-08-28 |
|||
### Fixed |
|||
- Removed deprecation warnings to STDERR to avoid them leaking to the end-user (backported) |
|||
|
|||
## [1.18.0] - 2016-06-27 |
|||
### Added |
|||
- `./runtests` test runner with coverage tracking by default |
|||
- testing on OS X |
|||
- testing on Windows |
|||
- `UintFlag`, `Uint64Flag`, and `Int64Flag` types and supporting code |
|||
|
|||
### Changed |
|||
- Use spaces for alignment in help/usage output instead of tabs, making the |
|||
output alignment consistent regardless of tab width |
|||
|
|||
### Fixed |
|||
- Printing of command aliases in help text |
|||
- Printing of visible flags for both struct and struct pointer flags |
|||
- Display the `help` subcommand when using `CommandCategories` |
|||
- No longer swallows `panic`s that occur within the `Action`s themselves when |
|||
detecting the signature of the `Action` field |
|||
|
|||
## [1.17.1] - 2016-08-28 |
|||
### Fixed |
|||
- Removed deprecation warnings to STDERR to avoid them leaking to the end-user |
|||
|
|||
## [1.17.0] - 2016-05-09 |
|||
### Added |
|||
- Pluggable flag-level help text rendering via `cli.DefaultFlagStringFunc` |
|||
- `context.GlobalBoolT` was added as an analogue to `context.GlobalBool` |
|||
- Support for hiding commands by setting `Hidden: true` -- this will hide the |
|||
commands in help output |
|||
|
|||
### Changed |
|||
- `Float64Flag`, `IntFlag`, and `DurationFlag` default values are no longer |
|||
quoted in help text output. |
|||
- All flag types now include `(default: {value})` strings following usage when a |
|||
default value can be (reasonably) detected. |
|||
- `IntSliceFlag` and `StringSliceFlag` usage strings are now more consistent |
|||
with non-slice flag types |
|||
- Apps now exit with a code of 3 if an unknown subcommand is specified |
|||
(previously they printed "No help topic for...", but still exited 0. This |
|||
makes it easier to script around apps built using `cli` since they can trust |
|||
that a 0 exit code indicated a successful execution. |
|||
- cleanups based on [Go Report Card |
|||
feedback](https://goreportcard.com/report/github.com/urfave/cli) |
|||
|
|||
## [1.16.1] - 2016-08-28 |
|||
### Fixed |
|||
- Removed deprecation warnings to STDERR to avoid them leaking to the end-user |
|||
|
|||
## [1.16.0] - 2016-05-02 |
|||
### Added |
|||
- `Hidden` field on all flag struct types to omit from generated help text |
|||
|
|||
### Changed |
|||
- `BashCompletionFlag` (`--enable-bash-completion`) is now omitted from |
|||
generated help text via the `Hidden` field |
|||
|
|||
### Fixed |
|||
- handling of error values in `HandleAction` and `HandleExitCoder` |
|||
|
|||
## [1.15.0] - 2016-04-30 |
|||
### Added |
|||
- This file! |
|||
- Support for placeholders in flag usage strings |
|||
- `App.Metadata` map for arbitrary data/state management |
|||
- `Set` and `GlobalSet` methods on `*cli.Context` for altering values after |
|||
parsing. |
|||
- Support for nested lookup of dot-delimited keys in structures loaded from |
|||
YAML. |
|||
|
|||
### Changed |
|||
- The `App.Action` and `Command.Action` now prefer a return signature of |
|||
`func(*cli.Context) error`, as defined by `cli.ActionFunc`. If a non-nil |
|||
`error` is returned, there may be two outcomes: |
|||
- If the error fulfills `cli.ExitCoder`, then `os.Exit` will be called |
|||
automatically |
|||
- Else the error is bubbled up and returned from `App.Run` |
|||
- Specifying an `Action` with the legacy return signature of |
|||
`func(*cli.Context)` will produce a deprecation message to stderr |
|||
- Specifying an `Action` that is not a `func` type will produce a non-zero exit |
|||
from `App.Run` |
|||
- Specifying an `Action` func that has an invalid (input) signature will |
|||
produce a non-zero exit from `App.Run` |
|||
|
|||
### Deprecated |
|||
- <a name="deprecated-cli-app-runandexitonerror"></a> |
|||
`cli.App.RunAndExitOnError`, which should now be done by returning an error |
|||
that fulfills `cli.ExitCoder` to `cli.App.Run`. |
|||
- <a name="deprecated-cli-app-action-signature"></a> the legacy signature for |
|||
`cli.App.Action` of `func(*cli.Context)`, which should now have a return |
|||
signature of `func(*cli.Context) error`, as defined by `cli.ActionFunc`. |
|||
|
|||
### Fixed |
|||
- Added missing `*cli.Context.GlobalFloat64` method |
|||
|
|||
## [1.14.0] - 2016-04-03 (backfilled 2016-04-25) |
|||
### Added |
|||
- Codebeat badge |
|||
- Support for categorization via `CategorizedHelp` and `Categories` on app. |
|||
|
|||
### Changed |
|||
- Use `filepath.Base` instead of `path.Base` in `Name` and `HelpName`. |
|||
|
|||
### Fixed |
|||
- Ensure version is not shown in help text when `HideVersion` set. |
|||
|
|||
## [1.13.0] - 2016-03-06 (backfilled 2016-04-25) |
|||
### Added |
|||
- YAML file input support. |
|||
- `NArg` method on context. |
|||
|
|||
## [1.12.0] - 2016-02-17 (backfilled 2016-04-25) |
|||
### Added |
|||
- Custom usage error handling. |
|||
- Custom text support in `USAGE` section of help output. |
|||
- Improved help messages for empty strings. |
|||
- AppVeyor CI configuration. |
|||
|
|||
### Changed |
|||
- Removed `panic` from default help printer func. |
|||
- De-duping and optimizations. |
|||
|
|||
### Fixed |
|||
- Correctly handle `Before`/`After` at command level when no subcommands. |
|||
- Case of literal `-` argument causing flag reordering. |
|||
- Environment variable hints on Windows. |
|||
- Docs updates. |
|||
|
|||
## [1.11.1] - 2015-12-21 (backfilled 2016-04-25) |
|||
### Changed |
|||
- Use `path.Base` in `Name` and `HelpName` |
|||
- Export `GetName` on flag types. |
|||
|
|||
### Fixed |
|||
- Flag parsing when skipping is enabled. |
|||
- Test output cleanup. |
|||
- Move completion check to account for empty input case. |
|||
|
|||
## [1.11.0] - 2015-11-15 (backfilled 2016-04-25) |
|||
### Added |
|||
- Destination scan support for flags. |
|||
- Testing against `tip` in Travis CI config. |
|||
|
|||
### Changed |
|||
- Go version in Travis CI config. |
|||
|
|||
### Fixed |
|||
- Removed redundant tests. |
|||
- Use correct example naming in tests. |
|||
|
|||
## [1.10.2] - 2015-10-29 (backfilled 2016-04-25) |
|||
### Fixed |
|||
- Remove unused var in bash completion. |
|||
|
|||
## [1.10.1] - 2015-10-21 (backfilled 2016-04-25) |
|||
### Added |
|||
- Coverage and reference logos in README. |
|||
|
|||
### Fixed |
|||
- Use specified values in help and version parsing. |
|||
- Only display app version and help message once. |
|||
|
|||
## [1.10.0] - 2015-10-06 (backfilled 2016-04-25) |
|||
### Added |
|||
- More tests for existing functionality. |
|||
- `ArgsUsage` at app and command level for help text flexibility. |
|||
|
|||
### Fixed |
|||
- Honor `HideHelp` and `HideVersion` in `App.Run`. |
|||
- Remove juvenile word from README. |
|||
|
|||
## [1.9.0] - 2015-09-08 (backfilled 2016-04-25) |
|||
### Added |
|||
- `FullName` on command with accompanying help output update. |
|||
- Set default `$PROG` in bash completion. |
|||
|
|||
### Changed |
|||
- Docs formatting. |
|||
|
|||
### Fixed |
|||
- Removed self-referential imports in tests. |
|||
|
|||
## [1.8.0] - 2015-06-30 (backfilled 2016-04-25) |
|||
### Added |
|||
- Support for `Copyright` at app level. |
|||
- `Parent` func at context level to walk up context lineage. |
|||
|
|||
### Fixed |
|||
- Global flag processing at top level. |
|||
|
|||
## [1.7.1] - 2015-06-11 (backfilled 2016-04-25) |
|||
### Added |
|||
- Aggregate errors from `Before`/`After` funcs. |
|||
- Doc comments on flag structs. |
|||
- Include non-global flags when checking version and help. |
|||
- Travis CI config updates. |
|||
|
|||
### Fixed |
|||
- Ensure slice type flags have non-nil values. |
|||
- Collect global flags from the full command hierarchy. |
|||
- Docs prose. |
|||
|
|||
## [1.7.0] - 2015-05-03 (backfilled 2016-04-25) |
|||
### Changed |
|||
- `HelpPrinter` signature includes output writer. |
|||
|
|||
### Fixed |
|||
- Specify go 1.1+ in docs. |
|||
- Set `Writer` when running command as app. |
|||
|
|||
## [1.6.0] - 2015-03-23 (backfilled 2016-04-25) |
|||
### Added |
|||
- Multiple author support. |
|||
- `NumFlags` at context level. |
|||
- `Aliases` at command level. |
|||
|
|||
### Deprecated |
|||
- `ShortName` at command level. |
|||
|
|||
### Fixed |
|||
- Subcommand help output. |
|||
- Backward compatible support for deprecated `Author` and `Email` fields. |
|||
- Docs regarding `Names`/`Aliases`. |
|||
|
|||
## [1.5.0] - 2015-02-20 (backfilled 2016-04-25) |
|||
### Added |
|||
- `After` hook func support at app and command level. |
|||
|
|||
### Fixed |
|||
- Use parsed context when running command as subcommand. |
|||
- Docs prose. |
|||
|
|||
## [1.4.1] - 2015-01-09 (backfilled 2016-04-25) |
|||
### Added |
|||
- Support for hiding `-h / --help` flags, but not `help` subcommand. |
|||
- Stop flag parsing after `--`. |
|||
|
|||
### Fixed |
|||
- Help text for generic flags to specify single value. |
|||
- Use double quotes in output for defaults. |
|||
- Use `ParseInt` instead of `ParseUint` for int environment var values. |
|||
- Use `0` as base when parsing int environment var values. |
|||
|
|||
## [1.4.0] - 2014-12-12 (backfilled 2016-04-25) |
|||
### Added |
|||
- Support for environment variable lookup "cascade". |
|||
- Support for `Stdout` on app for output redirection. |
|||
|
|||
### Fixed |
|||
- Print command help instead of app help in `ShowCommandHelp`. |
|||
|
|||
## [1.3.1] - 2014-11-13 (backfilled 2016-04-25) |
|||
### Added |
|||
- Docs and example code updates. |
|||
|
|||
### Changed |
|||
- Default `-v / --version` flag made optional. |
|||
|
|||
## [1.3.0] - 2014-08-10 (backfilled 2016-04-25) |
|||
### Added |
|||
- `FlagNames` at context level. |
|||
- Exposed `VersionPrinter` var for more control over version output. |
|||
- Zsh completion hook. |
|||
- `AUTHOR` section in default app help template. |
|||
- Contribution guidelines. |
|||
- `DurationFlag` type. |
|||
|
|||
## [1.2.0] - 2014-08-02 |
|||
### Added |
|||
- Support for environment variable defaults on flags plus tests. |
|||
|
|||
## [1.1.0] - 2014-07-15 |
|||
### Added |
|||
- Bash completion. |
|||
- Optional hiding of built-in help command. |
|||
- Optional skipping of flag parsing at command level. |
|||
- `Author`, `Email`, and `Compiled` metadata on app. |
|||
- `Before` hook func support at app and command level. |
|||
- `CommandNotFound` func support at app level. |
|||
- Command reference available on context. |
|||
- `GenericFlag` type. |
|||
- `Float64Flag` type. |
|||
- `BoolTFlag` type. |
|||
- `IsSet` flag helper on context. |
|||
- More flag lookup funcs at context level. |
|||
- More tests & docs. |
|||
|
|||
### Changed |
|||
- Help template updates to account for presence/absence of flags. |
|||
- Separated subcommand help template. |
|||
- Exposed `HelpPrinter` var for more control over help output. |
|||
|
|||
## [1.0.0] - 2013-11-01 |
|||
### Added |
|||
- `help` flag in default app flag set and each command flag set. |
|||
- Custom handling of argument parsing errors. |
|||
- Command lookup by name at app level. |
|||
- `StringSliceFlag` type and supporting `StringSlice` type. |
|||
- `IntSliceFlag` type and supporting `IntSlice` type. |
|||
- Slice type flag lookups by name at context level. |
|||
- Export of app and command help functions. |
|||
- More tests & docs. |
|||
|
|||
## 0.1.0 - 2013-07-22 |
|||
### Added |
|||
- Initial implementation. |
|||
|
|||
[Unreleased]: https://github.com/urfave/cli/compare/v1.18.0...HEAD |
|||
[1.18.0]: https://github.com/urfave/cli/compare/v1.17.0...v1.18.0 |
|||
[1.17.0]: https://github.com/urfave/cli/compare/v1.16.0...v1.17.0 |
|||
[1.16.0]: https://github.com/urfave/cli/compare/v1.15.0...v1.16.0 |
|||
[1.15.0]: https://github.com/urfave/cli/compare/v1.14.0...v1.15.0 |
|||
[1.14.0]: https://github.com/urfave/cli/compare/v1.13.0...v1.14.0 |
|||
[1.13.0]: https://github.com/urfave/cli/compare/v1.12.0...v1.13.0 |
|||
[1.12.0]: https://github.com/urfave/cli/compare/v1.11.1...v1.12.0 |
|||
[1.11.1]: https://github.com/urfave/cli/compare/v1.11.0...v1.11.1 |
|||
[1.11.0]: https://github.com/urfave/cli/compare/v1.10.2...v1.11.0 |
|||
[1.10.2]: https://github.com/urfave/cli/compare/v1.10.1...v1.10.2 |
|||
[1.10.1]: https://github.com/urfave/cli/compare/v1.10.0...v1.10.1 |
|||
[1.10.0]: https://github.com/urfave/cli/compare/v1.9.0...v1.10.0 |
|||
[1.9.0]: https://github.com/urfave/cli/compare/v1.8.0...v1.9.0 |
|||
[1.8.0]: https://github.com/urfave/cli/compare/v1.7.1...v1.8.0 |
|||
[1.7.1]: https://github.com/urfave/cli/compare/v1.7.0...v1.7.1 |
|||
[1.7.0]: https://github.com/urfave/cli/compare/v1.6.0...v1.7.0 |
|||
[1.6.0]: https://github.com/urfave/cli/compare/v1.5.0...v1.6.0 |
|||
[1.5.0]: https://github.com/urfave/cli/compare/v1.4.1...v1.5.0 |
|||
[1.4.1]: https://github.com/urfave/cli/compare/v1.4.0...v1.4.1 |
|||
[1.4.0]: https://github.com/urfave/cli/compare/v1.3.1...v1.4.0 |
|||
[1.3.1]: https://github.com/urfave/cli/compare/v1.3.0...v1.3.1 |
|||
[1.3.0]: https://github.com/urfave/cli/compare/v1.2.0...v1.3.0 |
|||
[1.2.0]: https://github.com/urfave/cli/compare/v1.1.0...v1.2.0 |
|||
[1.1.0]: https://github.com/urfave/cli/compare/v1.0.0...v1.1.0 |
|||
[1.0.0]: https://github.com/urfave/cli/compare/v0.1.0...v1.0.0 |
|||
@ -0,0 +1,74 @@ |
|||
# Contributor Covenant Code of Conduct |
|||
|
|||
## Our Pledge |
|||
|
|||
In the interest of fostering an open and welcoming environment, we as |
|||
contributors and maintainers pledge to making participation in our project and |
|||
our community a harassment-free experience for everyone, regardless of age, body |
|||
size, disability, ethnicity, gender identity and expression, level of experience, |
|||
education, socio-economic status, nationality, personal appearance, race, |
|||
religion, or sexual identity and orientation. |
|||
|
|||
## Our Standards |
|||
|
|||
Examples of behavior that contributes to creating a positive environment |
|||
include: |
|||
|
|||
* Using welcoming and inclusive language |
|||
* Being respectful of differing viewpoints and experiences |
|||
* Gracefully accepting constructive criticism |
|||
* Focusing on what is best for the community |
|||
* Showing empathy towards other community members |
|||
|
|||
Examples of unacceptable behavior by participants include: |
|||
|
|||
* The use of sexualized language or imagery and unwelcome sexual attention or |
|||
advances |
|||
* Trolling, insulting/derogatory comments, and personal or political attacks |
|||
* Public or private harassment |
|||
* Publishing others' private information, such as a physical or electronic |
|||
address, without explicit permission |
|||
* Other conduct which could reasonably be considered inappropriate in a |
|||
professional setting |
|||
|
|||
## Our Responsibilities |
|||
|
|||
Project maintainers are responsible for clarifying the standards of acceptable |
|||
behavior and are expected to take appropriate and fair corrective action in |
|||
response to any instances of unacceptable behavior. |
|||
|
|||
Project maintainers have the right and responsibility to remove, edit, or |
|||
reject comments, commits, code, wiki edits, issues, and other contributions |
|||
that are not aligned to this Code of Conduct, or to ban temporarily or |
|||
permanently any contributor for other behaviors that they deem inappropriate, |
|||
threatening, offensive, or harmful. |
|||
|
|||
## Scope |
|||
|
|||
This Code of Conduct applies both within project spaces and in public spaces |
|||
when an individual is representing the project or its community. Examples of |
|||
representing a project or community include using an official project e-mail |
|||
address, posting via an official social media account, or acting as an appointed |
|||
representative at an online or offline event. Representation of a project may be |
|||
further defined and clarified by project maintainers. |
|||
|
|||
## Enforcement |
|||
|
|||
Instances of abusive, harassing, or otherwise unacceptable behavior may be |
|||
reported by contacting Dan Buch at dan@meatballhat.com. All complaints will be |
|||
reviewed and investigated and will result in a response that is deemed necessary |
|||
and appropriate to the circumstances. The project team is obligated to maintain |
|||
confidentiality with regard to the reporter of an incident. Further details of |
|||
specific enforcement policies may be posted separately. |
|||
|
|||
Project maintainers who do not follow or enforce the Code of Conduct in good |
|||
faith may face temporary or permanent repercussions as determined by other |
|||
members of the project's leadership. |
|||
|
|||
## Attribution |
|||
|
|||
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, |
|||
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html |
|||
|
|||
[homepage]: https://www.contributor-covenant.org |
|||
|
|||
@ -0,0 +1,19 @@ |
|||
## Contributing |
|||
|
|||
**NOTE**: the primary maintainer(s) may be found in |
|||
[./MAINTAINERS.md](./MAINTAINERS.md). |
|||
|
|||
Feel free to put up a pull request to fix a bug or maybe add a feature. I will |
|||
give it a code review and make sure that it does not break backwards |
|||
compatibility. If I or any other collaborators agree that it is in line with |
|||
the vision of the project, we will work with you to get the code into |
|||
a mergeable state and merge it into the master branch. |
|||
|
|||
If you have contributed something significant to the project, we will most |
|||
likely add you as a collaborator. As a collaborator you are given the ability |
|||
to merge others pull requests. It is very important that new code does not |
|||
break existing code, so be careful about what code you do choose to merge. |
|||
|
|||
If you feel like you have contributed to the project but have not yet been added |
|||
as a collaborator, we probably forgot to add you :sweat_smile:. Please open an |
|||
issue! |
|||
@ -0,0 +1,21 @@ |
|||
MIT License |
|||
|
|||
Copyright (c) 2016 Jeremy Saenz & Contributors |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|||
of this software and associated documentation files (the "Software"), to deal |
|||
in the Software without restriction, including without limitation the rights |
|||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|||
copies of the Software, and to permit persons to whom the Software is |
|||
furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in all |
|||
copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
SOFTWARE. |
|||
@ -0,0 +1 @@ |
|||
- @meatballhat |
|||
File diff suppressed because it is too large
@ -0,0 +1,508 @@ |
|||
package cli |
|||
|
|||
import ( |
|||
"fmt" |
|||
"io" |
|||
"io/ioutil" |
|||
"os" |
|||
"path/filepath" |
|||
"sort" |
|||
"time" |
|||
) |
|||
|
|||
var ( |
|||
changeLogURL = "https://github.com/urfave/cli/blob/master/CHANGELOG.md" |
|||
appActionDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-action-signature", changeLogURL) |
|||
runAndExitOnErrorDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-runandexitonerror", changeLogURL) |
|||
|
|||
contactSysadmin = "This is an error in the application. Please contact the distributor of this application if this is not you." |
|||
|
|||
errInvalidActionType = NewExitError("ERROR invalid Action type. "+ |
|||
fmt.Sprintf("Must be `func(*Context`)` or `func(*Context) error). %s", contactSysadmin)+ |
|||
fmt.Sprintf("See %s", appActionDeprecationURL), 2) |
|||
) |
|||
|
|||
// App is the main structure of a cli application. It is recommended that
|
|||
// an app be created with the cli.NewApp() function
|
|||
type App struct { |
|||
// The name of the program. Defaults to path.Base(os.Args[0])
|
|||
Name string |
|||
// Full name of command for help, defaults to Name
|
|||
HelpName string |
|||
// Description of the program.
|
|||
Usage string |
|||
// Text to override the USAGE section of help
|
|||
UsageText string |
|||
// Description of the program argument format.
|
|||
ArgsUsage string |
|||
// Version of the program
|
|||
Version string |
|||
// Description of the program
|
|||
Description string |
|||
// List of commands to execute
|
|||
Commands []Command |
|||
// List of flags to parse
|
|||
Flags []Flag |
|||
// Boolean to enable bash completion commands
|
|||
EnableBashCompletion bool |
|||
// Boolean to hide built-in help command
|
|||
HideHelp bool |
|||
// Boolean to hide built-in version flag and the VERSION section of help
|
|||
HideVersion bool |
|||
// Populate on app startup, only gettable through method Categories()
|
|||
categories CommandCategories |
|||
// An action to execute when the bash-completion flag is set
|
|||
BashComplete BashCompleteFunc |
|||
// An action to execute before any subcommands are run, but after the context is ready
|
|||
// If a non-nil error is returned, no 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 action to execute when no subcommands are specified
|
|||
// Expects a `cli.ActionFunc` but will accept the *deprecated* signature of `func(*cli.Context) {}`
|
|||
// *Note*: support for the deprecated `Action` signature will be removed in a future version
|
|||
Action interface{} |
|||
|
|||
// Execute this function if the proper command cannot be found
|
|||
CommandNotFound CommandNotFoundFunc |
|||
// Execute this function if an usage error occurs
|
|||
OnUsageError OnUsageErrorFunc |
|||
// Compilation date
|
|||
Compiled time.Time |
|||
// List of all authors who contributed
|
|||
Authors []Author |
|||
// Copyright of the binary if any
|
|||
Copyright string |
|||
// Name of Author (Note: Use App.Authors, this is deprecated)
|
|||
Author string |
|||
// Email of Author (Note: Use App.Authors, this is deprecated)
|
|||
Email string |
|||
// Writer writer to write output to
|
|||
Writer io.Writer |
|||
// ErrWriter writes error output
|
|||
ErrWriter io.Writer |
|||
// Execute this function to handle ExitErrors. If not provided, HandleExitCoder is provided to
|
|||
// function as a default, so this is optional.
|
|||
ExitErrHandler ExitErrHandlerFunc |
|||
// Other custom info
|
|||
Metadata map[string]interface{} |
|||
// Carries a function which returns app specific info.
|
|||
ExtraInfo func() map[string]string |
|||
// CustomAppHelpTemplate the text template for app help topic.
|
|||
// cli.go uses text/template to render templates. You can
|
|||
// render custom help text by setting this variable.
|
|||
CustomAppHelpTemplate string |
|||
|
|||
didSetup bool |
|||
} |
|||
|
|||
// Tries to find out when this binary was compiled.
|
|||
// Returns the current time if it fails to find it.
|
|||
func compileTime() time.Time { |
|||
info, err := os.Stat(os.Args[0]) |
|||
if err != nil { |
|||
return time.Now() |
|||
} |
|||
return info.ModTime() |
|||
} |
|||
|
|||
// NewApp creates a new cli Application with some reasonable defaults for Name,
|
|||
// Usage, Version and Action.
|
|||
func NewApp() *App { |
|||
return &App{ |
|||
Name: filepath.Base(os.Args[0]), |
|||
HelpName: filepath.Base(os.Args[0]), |
|||
Usage: "A new cli application", |
|||
UsageText: "", |
|||
Version: "0.0.0", |
|||
BashComplete: DefaultAppComplete, |
|||
Action: helpCommand.Action, |
|||
Compiled: compileTime(), |
|||
Writer: os.Stdout, |
|||
} |
|||
} |
|||
|
|||
// Setup runs initialization code to ensure all data structures are ready for
|
|||
// `Run` or inspection prior to `Run`. It is internally called by `Run`, but
|
|||
// will return early if setup has already happened.
|
|||
func (a *App) Setup() { |
|||
if a.didSetup { |
|||
return |
|||
} |
|||
|
|||
a.didSetup = true |
|||
|
|||
if a.Author != "" || a.Email != "" { |
|||
a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email}) |
|||
} |
|||
|
|||
newCmds := []Command{} |
|||
for _, c := range a.Commands { |
|||
if c.HelpName == "" { |
|||
c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name) |
|||
} |
|||
newCmds = append(newCmds, c) |
|||
} |
|||
a.Commands = newCmds |
|||
|
|||
if a.Command(helpCommand.Name) == nil && !a.HideHelp { |
|||
a.Commands = append(a.Commands, helpCommand) |
|||
if (HelpFlag != BoolFlag{}) { |
|||
a.appendFlag(HelpFlag) |
|||
} |
|||
} |
|||
|
|||
if !a.HideVersion { |
|||
a.appendFlag(VersionFlag) |
|||
} |
|||
|
|||
a.categories = CommandCategories{} |
|||
for _, command := range a.Commands { |
|||
a.categories = a.categories.AddCommand(command.Category, command) |
|||
} |
|||
sort.Sort(a.categories) |
|||
|
|||
if a.Metadata == nil { |
|||
a.Metadata = make(map[string]interface{}) |
|||
} |
|||
|
|||
if a.Writer == nil { |
|||
a.Writer = os.Stdout |
|||
} |
|||
} |
|||
|
|||
// Run is the entry point to the cli app. Parses the arguments slice and routes
|
|||
// to the proper flag/args combination
|
|||
func (a *App) Run(arguments []string) (err error) { |
|||
a.Setup() |
|||
|
|||
// handle the completion flag separately from the flagset since
|
|||
// completion could be attempted after a flag, but before its value was put
|
|||
// on the command line. this causes the flagset to interpret the completion
|
|||
// flag name as the value of the flag before it which is undesirable
|
|||
// note that we can only do this because the shell autocomplete function
|
|||
// always appends the completion flag at the end of the command
|
|||
shellComplete, arguments := checkShellCompleteFlag(a, arguments) |
|||
|
|||
// parse flags
|
|||
set, err := flagSet(a.Name, a.Flags) |
|||
if err != nil { |
|||
return err |
|||
} |
|||
|
|||
set.SetOutput(ioutil.Discard) |
|||
err = set.Parse(arguments[1:]) |
|||
nerr := normalizeFlags(a.Flags, set) |
|||
context := NewContext(a, set, nil) |
|||
if nerr != nil { |
|||
fmt.Fprintln(a.Writer, nerr) |
|||
ShowAppHelp(context) |
|||
return nerr |
|||
} |
|||
context.shellComplete = shellComplete |
|||
|
|||
if checkCompletions(context) { |
|||
return nil |
|||
} |
|||
|
|||
if err != nil { |
|||
if a.OnUsageError != nil { |
|||
err := a.OnUsageError(context, err, false) |
|||
a.handleExitCoder(context, err) |
|||
return err |
|||
} |
|||
fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error()) |
|||
ShowAppHelp(context) |
|||
return err |
|||
} |
|||
|
|||
if !a.HideHelp && checkHelp(context) { |
|||
ShowAppHelp(context) |
|||
return nil |
|||
} |
|||
|
|||
if !a.HideVersion && checkVersion(context) { |
|||
ShowVersion(context) |
|||
return nil |
|||
} |
|||
|
|||
if a.After != nil { |
|||
defer func() { |
|||
if afterErr := a.After(context); afterErr != nil { |
|||
if err != nil { |
|||
err = NewMultiError(err, afterErr) |
|||
} else { |
|||
err = afterErr |
|||
} |
|||
} |
|||
}() |
|||
} |
|||
|
|||
if a.Before != nil { |
|||
beforeErr := a.Before(context) |
|||
if beforeErr != nil { |
|||
fmt.Fprintf(a.Writer, "%v\n\n", beforeErr) |
|||
ShowAppHelp(context) |
|||
a.handleExitCoder(context, beforeErr) |
|||
err = beforeErr |
|||
return err |
|||
} |
|||
} |
|||
|
|||
args := context.Args() |
|||
if args.Present() { |
|||
name := args.First() |
|||
c := a.Command(name) |
|||
if c != nil { |
|||
return c.Run(context) |
|||
} |
|||
} |
|||
|
|||
if a.Action == nil { |
|||
a.Action = helpCommand.Action |
|||
} |
|||
|
|||
// Run default Action
|
|||
err = HandleAction(a.Action, context) |
|||
|
|||
a.handleExitCoder(context, err) |
|||
return err |
|||
} |
|||
|
|||
// RunAndExitOnError calls .Run() and exits non-zero if an error was returned
|
|||
//
|
|||
// Deprecated: instead you should return an error that fulfills cli.ExitCoder
|
|||
// to cli.App.Run. This will cause the application to exit with the given eror
|
|||
// code in the cli.ExitCoder
|
|||
func (a *App) RunAndExitOnError() { |
|||
if err := a.Run(os.Args); err != nil { |
|||
fmt.Fprintln(a.errWriter(), err) |
|||
OsExiter(1) |
|||
} |
|||
} |
|||
|
|||
// RunAsSubcommand invokes the subcommand given the context, parses ctx.Args() to
|
|||
// generate command-specific flags
|
|||
func (a *App) RunAsSubcommand(ctx *Context) (err error) { |
|||
// append help to commands
|
|||
if len(a.Commands) > 0 { |
|||
if a.Command(helpCommand.Name) == nil && !a.HideHelp { |
|||
a.Commands = append(a.Commands, helpCommand) |
|||
if (HelpFlag != BoolFlag{}) { |
|||
a.appendFlag(HelpFlag) |
|||
} |
|||
} |
|||
} |
|||
|
|||
newCmds := []Command{} |
|||
for _, c := range a.Commands { |
|||
if c.HelpName == "" { |
|||
c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name) |
|||
} |
|||
newCmds = append(newCmds, c) |
|||
} |
|||
a.Commands = newCmds |
|||
|
|||
// parse flags
|
|||
set, err := flagSet(a.Name, a.Flags) |
|||
if err != nil { |
|||
return err |
|||
} |
|||
|
|||
set.SetOutput(ioutil.Discard) |
|||
err = set.Parse(ctx.Args().Tail()) |
|||
nerr := normalizeFlags(a.Flags, set) |
|||
context := NewContext(a, set, ctx) |
|||
|
|||
if nerr != nil { |
|||
fmt.Fprintln(a.Writer, nerr) |
|||
fmt.Fprintln(a.Writer) |
|||
if len(a.Commands) > 0 { |
|||
ShowSubcommandHelp(context) |
|||
} else { |
|||
ShowCommandHelp(ctx, context.Args().First()) |
|||
} |
|||
return nerr |
|||
} |
|||
|
|||
if checkCompletions(context) { |
|||
return nil |
|||
} |
|||
|
|||
if err != nil { |
|||
if a.OnUsageError != nil { |
|||
err = a.OnUsageError(context, err, true) |
|||
a.handleExitCoder(context, err) |
|||
return err |
|||
} |
|||
fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error()) |
|||
ShowSubcommandHelp(context) |
|||
return err |
|||
} |
|||
|
|||
if len(a.Commands) > 0 { |
|||
if checkSubcommandHelp(context) { |
|||
return nil |
|||
} |
|||
} else { |
|||
if checkCommandHelp(ctx, context.Args().First()) { |
|||
return nil |
|||
} |
|||
} |
|||
|
|||
if a.After != nil { |
|||
defer func() { |
|||
afterErr := a.After(context) |
|||
if afterErr != nil { |
|||
a.handleExitCoder(context, err) |
|||
if err != nil { |
|||
err = NewMultiError(err, afterErr) |
|||
} else { |
|||
err = afterErr |
|||
} |
|||
} |
|||
}() |
|||
} |
|||
|
|||
if a.Before != nil { |
|||
beforeErr := a.Before(context) |
|||
if beforeErr != nil { |
|||
a.handleExitCoder(context, beforeErr) |
|||
err = beforeErr |
|||
return err |
|||
} |
|||
} |
|||
|
|||
args := context.Args() |
|||
if args.Present() { |
|||
name := args.First() |
|||
c := a.Command(name) |
|||
if c != nil { |
|||
return c.Run(context) |
|||
} |
|||
} |
|||
|
|||
// Run default Action
|
|||
err = HandleAction(a.Action, context) |
|||
|
|||
a.handleExitCoder(context, err) |
|||
return err |
|||
} |
|||
|
|||
// Command returns the named command on App. Returns nil if the command does not exist
|
|||
func (a *App) Command(name string) *Command { |
|||
for _, c := range a.Commands { |
|||
if c.HasName(name) { |
|||
return &c |
|||
} |
|||
} |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Categories returns a slice containing all the categories with the commands they contain
|
|||
func (a *App) Categories() CommandCategories { |
|||
return a.categories |
|||
} |
|||
|
|||
// VisibleCategories returns a slice of categories and commands that are
|
|||
// Hidden=false
|
|||
func (a *App) VisibleCategories() []*CommandCategory { |
|||
ret := []*CommandCategory{} |
|||
for _, category := range a.categories { |
|||
if visible := func() *CommandCategory { |
|||
for _, command := range category.Commands { |
|||
if !command.Hidden { |
|||
return category |
|||
} |
|||
} |
|||
return nil |
|||
}(); visible != nil { |
|||
ret = append(ret, visible) |
|||
} |
|||
} |
|||
return ret |
|||
} |
|||
|
|||
// VisibleCommands returns a slice of the Commands with Hidden=false
|
|||
func (a *App) VisibleCommands() []Command { |
|||
ret := []Command{} |
|||
for _, command := range a.Commands { |
|||
if !command.Hidden { |
|||
ret = append(ret, command) |
|||
} |
|||
} |
|||
return ret |
|||
} |
|||
|
|||
// VisibleFlags returns a slice of the Flags with Hidden=false
|
|||
func (a *App) VisibleFlags() []Flag { |
|||
return visibleFlags(a.Flags) |
|||
} |
|||
|
|||
func (a *App) hasFlag(flag Flag) bool { |
|||
for _, f := range a.Flags { |
|||
if flag == f { |
|||
return true |
|||
} |
|||
} |
|||
|
|||
return false |
|||
} |
|||
|
|||
func (a *App) errWriter() io.Writer { |
|||
// When the app ErrWriter is nil use the package level one.
|
|||
if a.ErrWriter == nil { |
|||
return ErrWriter |
|||
} |
|||
|
|||
return a.ErrWriter |
|||
} |
|||
|
|||
func (a *App) appendFlag(flag Flag) { |
|||
if !a.hasFlag(flag) { |
|||
a.Flags = append(a.Flags, flag) |
|||
} |
|||
} |
|||
|
|||
func (a *App) handleExitCoder(context *Context, err error) { |
|||
if a.ExitErrHandler != nil { |
|||
a.ExitErrHandler(context, err) |
|||
} else { |
|||
HandleExitCoder(err) |
|||
} |
|||
} |
|||
|
|||
// Author represents someone who has contributed to a cli project.
|
|||
type Author struct { |
|||
Name string // The Authors name
|
|||
Email string // The Authors email
|
|||
} |
|||
|
|||
// String makes Author comply to the Stringer interface, to allow an easy print in the templating process
|
|||
func (a Author) String() string { |
|||
e := "" |
|||
if a.Email != "" { |
|||
e = " <" + a.Email + ">" |
|||
} |
|||
|
|||
return fmt.Sprintf("%v%v", a.Name, e) |
|||
} |
|||
|
|||
// 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
|
|||
// is run!
|
|||
func HandleAction(action interface{}, context *Context) (err error) { |
|||
if a, ok := action.(ActionFunc); ok { |
|||
return a(context) |
|||
} else if a, ok := action.(func(*Context) error); ok { |
|||
return a(context) |
|||
} else if a, ok := action.(func(*Context)); ok { // deprecated function signature
|
|||
a(context) |
|||
return nil |
|||
} |
|||
|
|||
return errInvalidActionType |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
version: "{build}" |
|||
|
|||
os: Windows Server 2016 |
|||
|
|||
image: Visual Studio 2017 |
|||
|
|||
clone_folder: c:\gopath\src\github.com\urfave\cli |
|||
|
|||
environment: |
|||
GOPATH: C:\gopath |
|||
GOVERSION: 1.8.x |
|||
PYTHON: C:\Python36-x64 |
|||
PYTHON_VERSION: 3.6.x |
|||
PYTHON_ARCH: 64 |
|||
|
|||
install: |
|||
- set PATH=%GOPATH%\bin;C:\go\bin;%PATH% |
|||
- go version |
|||
- go env |
|||
- go get github.com/urfave/gfmrun/... |
|||
- go get -v -t ./... |
|||
|
|||
build_script: |
|||
- python runtests vet |
|||
- python runtests test |
|||
- python runtests gfmrun |
|||
@ -0,0 +1,44 @@ |
|||
package cli |
|||
|
|||
// CommandCategories is a slice of *CommandCategory.
|
|||
type CommandCategories []*CommandCategory |
|||
|
|||
// CommandCategory is a category containing commands.
|
|||
type CommandCategory struct { |
|||
Name string |
|||
Commands Commands |
|||
} |
|||
|
|||
func (c CommandCategories) Less(i, j int) bool { |
|||
return lexicographicLess(c[i].Name, c[j].Name) |
|||
} |
|||
|
|||
func (c CommandCategories) Len() int { |
|||
return len(c) |
|||
} |
|||
|
|||
func (c CommandCategories) Swap(i, j int) { |
|||
c[i], c[j] = c[j], c[i] |
|||
} |
|||
|
|||
// AddCommand adds a command to a category.
|
|||
func (c CommandCategories) AddCommand(category string, command Command) CommandCategories { |
|||
for _, commandCategory := range c { |
|||
if commandCategory.Name == category { |
|||
commandCategory.Commands = append(commandCategory.Commands, command) |
|||
return c |
|||
} |
|||
} |
|||
return append(c, &CommandCategory{Name: category, Commands: []Command{command}}) |
|||
} |
|||
|
|||
// VisibleCommands returns a slice of the Commands with Hidden=false
|
|||
func (c *CommandCategory) VisibleCommands() []Command { |
|||
ret := []Command{} |
|||
for _, command := range c.Commands { |
|||
if !command.Hidden { |
|||
ret = append(ret, command) |
|||
} |
|||
} |
|||
return ret |
|||
} |
|||
@ -0,0 +1,22 @@ |
|||
// Package cli provides a minimal framework for creating and organizing command line
|
|||
// Go applications. cli is designed to be easy to understand and write, the most simple
|
|||
// cli application can be written as follows:
|
|||
// func main() {
|
|||
// cli.NewApp().Run(os.Args)
|
|||
// }
|
|||
//
|
|||
// Of course this application does not do much, so let's make this an actual application:
|
|||
// func main() {
|
|||
// app := cli.NewApp()
|
|||
// app.Name = "greet"
|
|||
// app.Usage = "say a greeting"
|
|||
// app.Action = func(c *cli.Context) error {
|
|||
// println("Greetings")
|
|||
// return nil
|
|||
// }
|
|||
//
|
|||
// app.Run(os.Args)
|
|||
// }
|
|||
package cli |
|||
|
|||
//go:generate python ./generate-flag-types cli -i flag-types.json -o flag_generated.go
|
|||
@ -0,0 +1,336 @@ |
|||
package cli |
|||
|
|||
import ( |
|||
"flag" |
|||
"fmt" |
|||
"io/ioutil" |
|||
"sort" |
|||
"strings" |
|||
) |
|||
|
|||
// 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 |
|||
// The function to call when checking for bash command completions
|
|||
BashComplete BashCompleteFunc |
|||
// 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 interface{} |
|||
// TODO: replace `Action: interface{}` with `Action: ActionFunc` once some kind
|
|||
// of deprecation period has passed, maybe?
|
|||
|
|||
// 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 command
|
|||
HideHelp bool |
|||
// Boolean to hide this command from help or completion
|
|||
Hidden bool |
|||
// Boolean to enable short-option handling so user can combine several
|
|||
// single-character bool arguements into one
|
|||
// i.e. foobar -o -v -> foobar -ov
|
|||
UseShortOptionHandling bool |
|||
|
|||
// Full name of command for help, defaults to full command name, including parent commands.
|
|||
HelpName string |
|||
commandNamePath []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 lexicographicLess(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 |
|||
|
|||
// 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) |
|||
} |
|||
|
|||
if !c.HideHelp && (HelpFlag != BoolFlag{}) { |
|||
// append help to flags
|
|||
c.Flags = append( |
|||
c.Flags, |
|||
HelpFlag, |
|||
) |
|||
} |
|||
|
|||
set, err := c.parseFlags(ctx.Args().Tail()) |
|||
|
|||
context := NewContext(ctx.App, set, ctx) |
|||
context.Command = c |
|||
if checkCommandCompletions(context, c.Name) { |
|||
return nil |
|||
} |
|||
|
|||
if err != nil { |
|||
if c.OnUsageError != nil { |
|||
err := c.OnUsageError(context, err, false) |
|||
context.App.handleExitCoder(context, err) |
|||
return err |
|||
} |
|||
fmt.Fprintln(context.App.Writer, "Incorrect Usage:", err.Error()) |
|||
fmt.Fprintln(context.App.Writer) |
|||
ShowCommandHelp(context, c.Name) |
|||
return err |
|||
} |
|||
|
|||
if checkCommandHelp(context, c.Name) { |
|||
return nil |
|||
} |
|||
|
|||
if c.After != nil { |
|||
defer func() { |
|||
afterErr := c.After(context) |
|||
if afterErr != nil { |
|||
context.App.handleExitCoder(context, err) |
|||
if err != nil { |
|||
err = NewMultiError(err, afterErr) |
|||
} else { |
|||
err = afterErr |
|||
} |
|||
} |
|||
}() |
|||
} |
|||
|
|||
if c.Before != nil { |
|||
err = c.Before(context) |
|||
if err != nil { |
|||
ShowCommandHelp(context, c.Name) |
|||
context.App.handleExitCoder(context, err) |
|||
return err |
|||
} |
|||
} |
|||
|
|||
if c.Action == nil { |
|||
c.Action = helpSubcommand.Action |
|||
} |
|||
|
|||
err = HandleAction(c.Action, context) |
|||
|
|||
if err != nil { |
|||
context.App.handleExitCoder(context, err) |
|||
} |
|||
return err |
|||
} |
|||
|
|||
func (c *Command) parseFlags(args Args) (*flag.FlagSet, error) { |
|||
set, err := flagSet(c.Name, c.Flags) |
|||
if err != nil { |
|||
return nil, err |
|||
} |
|||
set.SetOutput(ioutil.Discard) |
|||
|
|||
if c.SkipFlagParsing { |
|||
return set, set.Parse(append([]string{"--"}, args...)) |
|||
} |
|||
|
|||
if c.UseShortOptionHandling { |
|||
args = translateShortOptions(args) |
|||
} |
|||
|
|||
if !c.SkipArgReorder { |
|||
args = reorderArgs(args) |
|||
} |
|||
|
|||
err = set.Parse(args) |
|||
if err != nil { |
|||
return nil, err |
|||
} |
|||
|
|||
err = normalizeFlags(c.Flags, set) |
|||
if err != nil { |
|||
return nil, err |
|||
} |
|||
|
|||
return set, nil |
|||
} |
|||
|
|||
// reorderArgs moves all flags before arguments as this is what flag expects
|
|||
func reorderArgs(args []string) []string { |
|||
var nonflags, flags []string |
|||
|
|||
readFlagValue := false |
|||
for i, arg := range args { |
|||
if arg == "--" { |
|||
nonflags = append(nonflags, args[i:]...) |
|||
break |
|||
} |
|||
|
|||
if readFlagValue && !strings.HasPrefix(arg, "-") && !strings.HasPrefix(arg, "--") { |
|||
readFlagValue = false |
|||
flags = append(flags, arg) |
|||
continue |
|||
} |
|||
readFlagValue = false |
|||
|
|||
if arg != "-" && strings.HasPrefix(arg, "-") { |
|||
flags = append(flags, arg) |
|||
|
|||
readFlagValue = !strings.Contains(arg, "=") |
|||
} else { |
|||
nonflags = append(nonflags, arg) |
|||
} |
|||
} |
|||
|
|||
return append(flags, nonflags...) |
|||
} |
|||
|
|||
func translateShortOptions(flagArgs Args) []string { |
|||
// separate combined flags
|
|||
var flagArgsSeparated []string |
|||
for _, flagArg := range flagArgs { |
|||
if strings.HasPrefix(flagArg, "-") && strings.HasPrefix(flagArg, "--") == false && len(flagArg) > 2 { |
|||
for _, flagChar := range flagArg[1:] { |
|||
flagArgsSeparated = append(flagArgsSeparated, "-"+string(flagChar)) |
|||
} |
|||
} else { |
|||
flagArgsSeparated = append(flagArgsSeparated, flagArg) |
|||
} |
|||
} |
|||
return flagArgsSeparated |
|||
} |
|||
|
|||
// 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) |
|||
} |
|||
|
|||
return append(names, c.Aliases...) |
|||
} |
|||
|
|||
// HasName returns true if Command.Name or Command.ShortName matches given name
|
|||
func (c Command) HasName(name string) bool { |
|||
for _, n := range c.Names() { |
|||
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 |
|||
|
|||
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.ErrWriter = ctx.App.ErrWriter |
|||
|
|||
app.categories = CommandCategories{} |
|||
for _, command := range c.Subcommands { |
|||
app.categories = app.categories.AddCommand(command.Category, command) |
|||
} |
|||
|
|||
sort.Sort(app.categories) |
|||
|
|||
// bash completion
|
|||
app.EnableBashCompletion = ctx.App.EnableBashCompletion |
|||
if c.BashComplete != nil { |
|||
app.BashComplete = c.BashComplete |
|||
} |
|||
|
|||
// set the actions
|
|||
app.Before = c.Before |
|||
app.After = c.After |
|||
if c.Action != nil { |
|||
app.Action = c.Action |
|||
} else { |
|||
app.Action = helpSubcommand.Action |
|||
} |
|||
app.OnUsageError = c.OnUsageError |
|||
|
|||
for index, cc := range app.Commands { |
|||
app.Commands[index].commandNamePath = []string{c.Name, cc.Name} |
|||
} |
|||
|
|||
return app.RunAsSubcommand(ctx) |
|||
} |
|||
|
|||
// VisibleFlags returns a slice of the Flags with Hidden=false
|
|||
func (c Command) VisibleFlags() []Flag { |
|||
return visibleFlags(c.Flags) |
|||
} |
|||
@ -0,0 +1,287 @@ |
|||
package cli |
|||
|
|||
import ( |
|||
"errors" |
|||
"flag" |
|||
"os" |
|||
"reflect" |
|||
"strings" |
|||
"syscall" |
|||
) |
|||
|
|||
// Context is a type that is passed through to
|
|||
// each Handler action in a cli application. Context
|
|||
// can be used to retrieve context-specific Args and
|
|||
// parsed command-line options.
|
|||
type Context struct { |
|||
App *App |
|||
Command Command |
|||
shellComplete bool |
|||
flagSet *flag.FlagSet |
|||
setFlags map[string]bool |
|||
parentContext *Context |
|||
} |
|||
|
|||
// NewContext creates a new context. For use in when invoking an App or Command action.
|
|||
func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context { |
|||
c := &Context{App: app, flagSet: set, parentContext: parentCtx} |
|||
|
|||
if parentCtx != nil { |
|||
c.shellComplete = parentCtx.shellComplete |
|||
} |
|||
|
|||
return c |
|||
} |
|||
|
|||
// NumFlags returns the number of flags set
|
|||
func (c *Context) NumFlags() int { |
|||
return c.flagSet.NFlag() |
|||
} |
|||
|
|||
// Set sets a context flag to a value.
|
|||
func (c *Context) Set(name, value string) error { |
|||
c.setFlags = nil |
|||
return c.flagSet.Set(name, value) |
|||
} |
|||
|
|||
// GlobalSet sets a context flag to a value on the global flagset
|
|||
func (c *Context) GlobalSet(name, value string) error { |
|||
globalContext(c).setFlags = nil |
|||
return globalContext(c).flagSet.Set(name, value) |
|||
} |
|||
|
|||
// IsSet determines if the flag was actually set
|
|||
func (c *Context) IsSet(name string) bool { |
|||
if c.setFlags == nil { |
|||
c.setFlags = make(map[string]bool) |
|||
|
|||
c.flagSet.Visit(func(f *flag.Flag) { |
|||
c.setFlags[f.Name] = true |
|||
}) |
|||
|
|||
c.flagSet.VisitAll(func(f *flag.Flag) { |
|||
if _, ok := c.setFlags[f.Name]; ok { |
|||
return |
|||
} |
|||
c.setFlags[f.Name] = false |
|||
}) |
|||
|
|||
// XXX hack to support IsSet for flags with EnvVar
|
|||
//
|
|||
// There isn't an easy way to do this with the current implementation since
|
|||
// whether a flag was set via an environment variable is very difficult to
|
|||
// determine here. Instead, we intend to introduce a backwards incompatible
|
|||
// change in version 2 to add `IsSet` to the Flag interface to push the
|
|||
// responsibility closer to where the information required to determine
|
|||
// whether a flag is set by non-standard means such as environment
|
|||
// variables is available.
|
|||
//
|
|||
// See https://github.com/urfave/cli/issues/294 for additional discussion
|
|||
flags := c.Command.Flags |
|||
if c.Command.Name == "" { // cannot == Command{} since it contains slice types
|
|||
if c.App != nil { |
|||
flags = c.App.Flags |
|||
} |
|||
} |
|||
for _, f := range flags { |
|||
eachName(f.GetName(), func(name string) { |
|||
if isSet, ok := c.setFlags[name]; isSet || !ok { |
|||
return |
|||
} |
|||
|
|||
val := reflect.ValueOf(f) |
|||
if val.Kind() == reflect.Ptr { |
|||
val = val.Elem() |
|||
} |
|||
|
|||
filePathValue := val.FieldByName("FilePath") |
|||
if filePathValue.IsValid() { |
|||
eachName(filePathValue.String(), func(filePath string) { |
|||
if _, err := os.Stat(filePath); err == nil { |
|||
c.setFlags[name] = true |
|||
return |
|||
} |
|||
}) |
|||
} |
|||
|
|||
envVarValue := val.FieldByName("EnvVar") |
|||
if envVarValue.IsValid() { |
|||
eachName(envVarValue.String(), func(envVar string) { |
|||
envVar = strings.TrimSpace(envVar) |
|||
if _, ok := syscall.Getenv(envVar); ok { |
|||
c.setFlags[name] = true |
|||
return |
|||
} |
|||
}) |
|||
} |
|||
}) |
|||
} |
|||
} |
|||
|
|||
return c.setFlags[name] |
|||
} |
|||
|
|||
// GlobalIsSet determines if the global flag was actually set
|
|||
func (c *Context) GlobalIsSet(name string) bool { |
|||
ctx := c |
|||
if ctx.parentContext != nil { |
|||
ctx = ctx.parentContext |
|||
} |
|||
|
|||
for ; ctx != nil; ctx = ctx.parentContext { |
|||
if ctx.IsSet(name) { |
|||
return true |
|||
} |
|||
} |
|||
return false |
|||
} |
|||
|
|||
// FlagNames returns a slice of flag names used in this context.
|
|||
func (c *Context) FlagNames() (names []string) { |
|||
for _, flag := range c.Command.Flags { |
|||
name := strings.Split(flag.GetName(), ",")[0] |
|||
if name == "help" { |
|||
continue |
|||
} |
|||
names = append(names, name) |
|||
} |
|||
return |
|||
} |
|||
|
|||
// GlobalFlagNames returns a slice of global flag names used by the app.
|
|||
func (c *Context) GlobalFlagNames() (names []string) { |
|||
for _, flag := range c.App.Flags { |
|||
name := strings.Split(flag.GetName(), ",")[0] |
|||
if name == "help" || name == "version" { |
|||
continue |
|||
} |
|||
names = append(names, name) |
|||
} |
|||
return |
|||
} |
|||
|
|||
// Parent returns the parent context, if any
|
|||
func (c *Context) Parent() *Context { |
|||
return c.parentContext |
|||
} |
|||
|
|||
// value returns the value of the flag coressponding to `name`
|
|||
func (c *Context) value(name string) interface{} { |
|||
return c.flagSet.Lookup(name).Value.(flag.Getter).Get() |
|||
} |
|||
|
|||
// Args contains apps console arguments
|
|||
type Args []string |
|||
|
|||
// Args returns the command line arguments associated with the context.
|
|||
func (c *Context) Args() Args { |
|||
args := Args(c.flagSet.Args()) |
|||
return args |
|||
} |
|||
|
|||
// NArg returns the number of the command line arguments.
|
|||
func (c *Context) NArg() int { |
|||
return len(c.Args()) |
|||
} |
|||
|
|||
// Get returns the nth argument, or else a blank string
|
|||
func (a Args) Get(n int) string { |
|||
if len(a) > n { |
|||
return a[n] |
|||
} |
|||
return "" |
|||
} |
|||
|
|||
// First returns the first argument, or else a blank string
|
|||
func (a Args) First() string { |
|||
return a.Get(0) |
|||
} |
|||
|
|||
// Tail returns the rest of the arguments (not the first one)
|
|||
// or else an empty string slice
|
|||
func (a Args) Tail() []string { |
|||
if len(a) >= 2 { |
|||
return []string(a)[1:] |
|||
} |
|||
return []string{} |
|||
} |
|||
|
|||
// Present checks if there are any arguments present
|
|||
func (a Args) Present() bool { |
|||
return len(a) != 0 |
|||
} |
|||
|
|||
// Swap swaps arguments at the given indexes
|
|||
func (a Args) Swap(from, to int) error { |
|||
if from >= len(a) || to >= len(a) { |
|||
return errors.New("index out of range") |
|||
} |
|||
a[from], a[to] = a[to], a[from] |
|||
return nil |
|||
} |
|||
|
|||
func globalContext(ctx *Context) *Context { |
|||
if ctx == nil { |
|||
return nil |
|||
} |
|||
|
|||
for { |
|||
if ctx.parentContext == nil { |
|||
return ctx |
|||
} |
|||
ctx = ctx.parentContext |
|||
} |
|||
} |
|||
|
|||
func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet { |
|||
if ctx.parentContext != nil { |
|||
ctx = ctx.parentContext |
|||
} |
|||
for ; ctx != nil; ctx = ctx.parentContext { |
|||
if f := ctx.flagSet.Lookup(name); f != nil { |
|||
return ctx.flagSet |
|||
} |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) { |
|||
switch ff.Value.(type) { |
|||
case *StringSlice: |
|||
default: |
|||
set.Set(name, ff.Value.String()) |
|||
} |
|||
} |
|||
|
|||
func normalizeFlags(flags []Flag, set *flag.FlagSet) error { |
|||
visited := make(map[string]bool) |
|||
set.Visit(func(f *flag.Flag) { |
|||
visited[f.Name] = true |
|||
}) |
|||
for _, f := range flags { |
|||
parts := strings.Split(f.GetName(), ",") |
|||
if len(parts) == 1 { |
|||
continue |
|||
} |
|||
var ff *flag.Flag |
|||
for _, name := range parts { |
|||
name = strings.Trim(name, " ") |
|||
if visited[name] { |
|||
if ff != nil { |
|||
return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name) |
|||
} |
|||
ff = set.Lookup(name) |
|||
} |
|||
} |
|||
if ff == nil { |
|||
continue |
|||
} |
|||
for _, name := range parts { |
|||
name = strings.Trim(name, " ") |
|||
if !visited[name] { |
|||
copyFlag(name, ff, set) |
|||
} |
|||
} |
|||
} |
|||
return nil |
|||
} |
|||
@ -0,0 +1,115 @@ |
|||
package cli |
|||
|
|||
import ( |
|||
"fmt" |
|||
"io" |
|||
"os" |
|||
"strings" |
|||
) |
|||
|
|||
// OsExiter is the function used when the app exits. If not set defaults to os.Exit.
|
|||
var OsExiter = os.Exit |
|||
|
|||
// ErrWriter is used to write errors to the user. This can be anything
|
|||
// implementing the io.Writer interface and defaults to os.Stderr.
|
|||
var ErrWriter io.Writer = os.Stderr |
|||
|
|||
// MultiError is an error that wraps multiple errors.
|
|||
type MultiError struct { |
|||
Errors []error |
|||
} |
|||
|
|||
// NewMultiError creates a new MultiError. Pass in one or more errors.
|
|||
func NewMultiError(err ...error) MultiError { |
|||
return MultiError{Errors: err} |
|||
} |
|||
|
|||
// Error implements the error interface.
|
|||
func (m MultiError) Error() string { |
|||
errs := make([]string, len(m.Errors)) |
|||
for i, err := range m.Errors { |
|||
errs[i] = err.Error() |
|||
} |
|||
|
|||
return strings.Join(errs, "\n") |
|||
} |
|||
|
|||
type ErrorFormatter interface { |
|||
Format(s fmt.State, verb rune) |
|||
} |
|||
|
|||
// ExitCoder is the interface checked by `App` and `Command` for a custom exit
|
|||
// code
|
|||
type ExitCoder interface { |
|||
error |
|||
ExitCode() int |
|||
} |
|||
|
|||
// ExitError fulfills both the builtin `error` interface and `ExitCoder`
|
|||
type ExitError struct { |
|||
exitCode int |
|||
message interface{} |
|||
} |
|||
|
|||
// NewExitError makes a new *ExitError
|
|||
func NewExitError(message interface{}, exitCode int) *ExitError { |
|||
return &ExitError{ |
|||
exitCode: exitCode, |
|||
message: message, |
|||
} |
|||
} |
|||
|
|||
// Error returns the string message, fulfilling the interface required by
|
|||
// `error`
|
|||
func (ee *ExitError) Error() string { |
|||
return fmt.Sprintf("%v", ee.message) |
|||
} |
|||
|
|||
// ExitCode returns the exit code, fulfilling the interface required by
|
|||
// `ExitCoder`
|
|||
func (ee *ExitError) ExitCode() int { |
|||
return ee.exitCode |
|||
} |
|||
|
|||
// HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
|
|||
// so prints the error to stderr (if it is non-empty) and calls OsExiter with the
|
|||
// given exit code. If the given error is a MultiError, then this func is
|
|||
// called on all members of the Errors slice and calls OsExiter with the last exit code.
|
|||
func HandleExitCoder(err error) { |
|||
if err == nil { |
|||
return |
|||
} |
|||
|
|||
if exitErr, ok := err.(ExitCoder); ok { |
|||
if err.Error() != "" { |
|||
if _, ok := exitErr.(ErrorFormatter); ok { |
|||
fmt.Fprintf(ErrWriter, "%+v\n", err) |
|||
} else { |
|||
fmt.Fprintln(ErrWriter, err) |
|||
} |
|||
} |
|||
OsExiter(exitErr.ExitCode()) |
|||
return |
|||
} |
|||
|
|||
if multiErr, ok := err.(MultiError); ok { |
|||
code := handleMultiError(multiErr) |
|||
OsExiter(code) |
|||
return |
|||
} |
|||
} |
|||
|
|||
func handleMultiError(multiErr MultiError) int { |
|||
code := 1 |
|||
for _, merr := range multiErr.Errors { |
|||
if multiErr2, ok := merr.(MultiError); ok { |
|||
code = handleMultiError(multiErr2) |
|||
} else { |
|||
fmt.Fprintln(ErrWriter, merr) |
|||
if exitErr, ok := merr.(ExitCoder); ok { |
|||
code = exitErr.ExitCode() |
|||
} |
|||
} |
|||
} |
|||
return code |
|||
} |
|||
@ -0,0 +1,93 @@ |
|||
[ |
|||
{ |
|||
"name": "Bool", |
|||
"type": "bool", |
|||
"value": false, |
|||
"context_default": "false", |
|||
"parser": "strconv.ParseBool(f.Value.String())" |
|||
}, |
|||
{ |
|||
"name": "BoolT", |
|||
"type": "bool", |
|||
"value": false, |
|||
"doctail": " that is true by default", |
|||
"context_default": "false", |
|||
"parser": "strconv.ParseBool(f.Value.String())" |
|||
}, |
|||
{ |
|||
"name": "Duration", |
|||
"type": "time.Duration", |
|||
"doctail": " (see https://golang.org/pkg/time/#ParseDuration)", |
|||
"context_default": "0", |
|||
"parser": "time.ParseDuration(f.Value.String())" |
|||
}, |
|||
{ |
|||
"name": "Float64", |
|||
"type": "float64", |
|||
"context_default": "0", |
|||
"parser": "strconv.ParseFloat(f.Value.String(), 64)" |
|||
}, |
|||
{ |
|||
"name": "Generic", |
|||
"type": "Generic", |
|||
"dest": false, |
|||
"context_default": "nil", |
|||
"context_type": "interface{}" |
|||
}, |
|||
{ |
|||
"name": "Int64", |
|||
"type": "int64", |
|||
"context_default": "0", |
|||
"parser": "strconv.ParseInt(f.Value.String(), 0, 64)" |
|||
}, |
|||
{ |
|||
"name": "Int", |
|||
"type": "int", |
|||
"context_default": "0", |
|||
"parser": "strconv.ParseInt(f.Value.String(), 0, 64)", |
|||
"parser_cast": "int(parsed)" |
|||
}, |
|||
{ |
|||
"name": "IntSlice", |
|||
"type": "*IntSlice", |
|||
"dest": false, |
|||
"context_default": "nil", |
|||
"context_type": "[]int", |
|||
"parser": "(f.Value.(*IntSlice)).Value(), error(nil)" |
|||
}, |
|||
{ |
|||
"name": "Int64Slice", |
|||
"type": "*Int64Slice", |
|||
"dest": false, |
|||
"context_default": "nil", |
|||
"context_type": "[]int64", |
|||
"parser": "(f.Value.(*Int64Slice)).Value(), error(nil)" |
|||
}, |
|||
{ |
|||
"name": "String", |
|||
"type": "string", |
|||
"context_default": "\"\"", |
|||
"parser": "f.Value.String(), error(nil)" |
|||
}, |
|||
{ |
|||
"name": "StringSlice", |
|||
"type": "*StringSlice", |
|||
"dest": false, |
|||
"context_default": "nil", |
|||
"context_type": "[]string", |
|||
"parser": "(f.Value.(*StringSlice)).Value(), error(nil)" |
|||
}, |
|||
{ |
|||
"name": "Uint64", |
|||
"type": "uint64", |
|||
"context_default": "0", |
|||
"parser": "strconv.ParseUint(f.Value.String(), 0, 64)" |
|||
}, |
|||
{ |
|||
"name": "Uint", |
|||
"type": "uint", |
|||
"context_default": "0", |
|||
"parser": "strconv.ParseUint(f.Value.String(), 0, 64)", |
|||
"parser_cast": "uint(parsed)" |
|||
} |
|||
] |
|||
@ -0,0 +1,786 @@ |
|||
package cli |
|||
|
|||
import ( |
|||
"flag" |
|||
"fmt" |
|||
"io/ioutil" |
|||
"reflect" |
|||
"runtime" |
|||
"strconv" |
|||
"strings" |
|||
"syscall" |
|||
"time" |
|||
) |
|||
|
|||
const defaultPlaceholder = "value" |
|||
|
|||
// BashCompletionFlag enables bash-completion for all commands and subcommands
|
|||
var BashCompletionFlag Flag = BoolFlag{ |
|||
Name: "generate-bash-completion", |
|||
Hidden: true, |
|||
} |
|||
|
|||
// VersionFlag prints the version for the application
|
|||
var VersionFlag Flag = BoolFlag{ |
|||
Name: "version, v", |
|||
Usage: "print the version", |
|||
} |
|||
|
|||
// HelpFlag prints the help for all commands and subcommands
|
|||
// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
|
|||
// unless HideHelp is set to true)
|
|||
var HelpFlag Flag = BoolFlag{ |
|||
Name: "help, h", |
|||
Usage: "show help", |
|||
} |
|||
|
|||
// FlagStringer converts a flag definition to a string. This is used by help
|
|||
// to display a flag.
|
|||
var FlagStringer FlagStringFunc = stringifyFlag |
|||
|
|||
// FlagNamePrefixer converts a full flag name and its placeholder into the help
|
|||
// message flag prefix. This is used by the default FlagStringer.
|
|||
var FlagNamePrefixer FlagNamePrefixFunc = prefixedNames |
|||
|
|||
// FlagEnvHinter annotates flag help message with the environment variable
|
|||
// details. This is used by the default FlagStringer.
|
|||
var FlagEnvHinter FlagEnvHintFunc = withEnvHint |
|||
|
|||
// FlagFileHinter annotates flag help message with the environment variable
|
|||
// details. This is used by the default FlagStringer.
|
|||
var FlagFileHinter FlagFileHintFunc = withFileHint |
|||
|
|||
// FlagsByName is a slice of Flag.
|
|||
type FlagsByName []Flag |
|||
|
|||
func (f FlagsByName) Len() int { |
|||
return len(f) |
|||
} |
|||
|
|||
func (f FlagsByName) Less(i, j int) bool { |
|||
return lexicographicLess(f[i].GetName(), f[j].GetName()) |
|||
} |
|||
|
|||
func (f FlagsByName) Swap(i, j int) { |
|||
f[i], f[j] = f[j], f[i] |
|||
} |
|||
|
|||
// Flag is a common interface related to parsing flags in cli.
|
|||
// For more advanced flag parsing techniques, it is recommended that
|
|||
// this interface be implemented.
|
|||
type Flag interface { |
|||
fmt.Stringer |
|||
// Apply Flag settings to the given flag set
|
|||
Apply(*flag.FlagSet) |
|||
GetName() string |
|||
} |
|||
|
|||
// errorableFlag is an interface that allows us to return errors during apply
|
|||
// it allows flags defined in this library to return errors in a fashion backwards compatible
|
|||
// TODO remove in v2 and modify the existing Flag interface to return errors
|
|||
type errorableFlag interface { |
|||
Flag |
|||
|
|||
ApplyWithError(*flag.FlagSet) error |
|||
} |
|||
|
|||
func flagSet(name string, flags []Flag) (*flag.FlagSet, error) { |
|||
set := flag.NewFlagSet(name, flag.ContinueOnError) |
|||
|
|||
for _, f := range flags { |
|||
//TODO remove in v2 when errorableFlag is removed
|
|||
if ef, ok := f.(errorableFlag); ok { |
|||
if err := ef.ApplyWithError(set); err != nil { |
|||
return nil, err |
|||
} |
|||
} else { |
|||
f.Apply(set) |
|||
} |
|||
} |
|||
return set, nil |
|||
} |
|||
|
|||
func eachName(longName string, fn func(string)) { |
|||
parts := strings.Split(longName, ",") |
|||
for _, name := range parts { |
|||
name = strings.Trim(name, " ") |
|||
fn(name) |
|||
} |
|||
} |
|||
|
|||
// Generic is a generic parseable type identified by a specific flag
|
|||
type Generic interface { |
|||
Set(value string) error |
|||
String() string |
|||
} |
|||
|
|||
// Apply takes the flagset and calls Set on the generic flag with the value
|
|||
// provided by the user for parsing by the flag
|
|||
// Ignores parsing errors
|
|||
func (f GenericFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError takes the flagset and calls Set on the generic flag with the value
|
|||
// provided by the user for parsing by the flag
|
|||
func (f GenericFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
val := f.Value |
|||
if fileEnvVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
if err := val.Set(fileEnvVal); err != nil { |
|||
return fmt.Errorf("could not parse %s as value for flag %s: %s", fileEnvVal, f.Name, err) |
|||
} |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
set.Var(f.Value, name, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// StringSlice is an opaque type for []string to satisfy flag.Value and flag.Getter
|
|||
type StringSlice []string |
|||
|
|||
// Set appends the string value to the list of values
|
|||
func (f *StringSlice) Set(value string) error { |
|||
*f = append(*f, value) |
|||
return nil |
|||
} |
|||
|
|||
// String returns a readable representation of this value (for usage defaults)
|
|||
func (f *StringSlice) String() string { |
|||
return fmt.Sprintf("%s", *f) |
|||
} |
|||
|
|||
// Value returns the slice of strings set by this flag
|
|||
func (f *StringSlice) Value() []string { |
|||
return *f |
|||
} |
|||
|
|||
// Get returns the slice of strings set by this flag
|
|||
func (f *StringSlice) Get() interface{} { |
|||
return *f |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f StringSliceFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f StringSliceFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
newVal := &StringSlice{} |
|||
for _, s := range strings.Split(envVal, ",") { |
|||
s = strings.TrimSpace(s) |
|||
if err := newVal.Set(s); err != nil { |
|||
return fmt.Errorf("could not parse %s as string value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
} |
|||
if f.Value == nil { |
|||
f.Value = newVal |
|||
} else { |
|||
*f.Value = *newVal |
|||
} |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Value == nil { |
|||
f.Value = &StringSlice{} |
|||
} |
|||
set.Var(f.Value, name, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// IntSlice is an opaque type for []int to satisfy flag.Value and flag.Getter
|
|||
type IntSlice []int |
|||
|
|||
// Set parses the value into an integer and appends it to the list of values
|
|||
func (f *IntSlice) Set(value string) error { |
|||
tmp, err := strconv.Atoi(value) |
|||
if err != nil { |
|||
return err |
|||
} |
|||
*f = append(*f, tmp) |
|||
return nil |
|||
} |
|||
|
|||
// String returns a readable representation of this value (for usage defaults)
|
|||
func (f *IntSlice) String() string { |
|||
return fmt.Sprintf("%#v", *f) |
|||
} |
|||
|
|||
// Value returns the slice of ints set by this flag
|
|||
func (f *IntSlice) Value() []int { |
|||
return *f |
|||
} |
|||
|
|||
// Get returns the slice of ints set by this flag
|
|||
func (f *IntSlice) Get() interface{} { |
|||
return *f |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f IntSliceFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f IntSliceFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
newVal := &IntSlice{} |
|||
for _, s := range strings.Split(envVal, ",") { |
|||
s = strings.TrimSpace(s) |
|||
if err := newVal.Set(s); err != nil { |
|||
return fmt.Errorf("could not parse %s as int slice value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
} |
|||
if f.Value == nil { |
|||
f.Value = newVal |
|||
} else { |
|||
*f.Value = *newVal |
|||
} |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Value == nil { |
|||
f.Value = &IntSlice{} |
|||
} |
|||
set.Var(f.Value, name, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Int64Slice is an opaque type for []int to satisfy flag.Value and flag.Getter
|
|||
type Int64Slice []int64 |
|||
|
|||
// Set parses the value into an integer and appends it to the list of values
|
|||
func (f *Int64Slice) Set(value string) error { |
|||
tmp, err := strconv.ParseInt(value, 10, 64) |
|||
if err != nil { |
|||
return err |
|||
} |
|||
*f = append(*f, tmp) |
|||
return nil |
|||
} |
|||
|
|||
// String returns a readable representation of this value (for usage defaults)
|
|||
func (f *Int64Slice) String() string { |
|||
return fmt.Sprintf("%#v", *f) |
|||
} |
|||
|
|||
// Value returns the slice of ints set by this flag
|
|||
func (f *Int64Slice) Value() []int64 { |
|||
return *f |
|||
} |
|||
|
|||
// Get returns the slice of ints set by this flag
|
|||
func (f *Int64Slice) Get() interface{} { |
|||
return *f |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f Int64SliceFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f Int64SliceFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
newVal := &Int64Slice{} |
|||
for _, s := range strings.Split(envVal, ",") { |
|||
s = strings.TrimSpace(s) |
|||
if err := newVal.Set(s); err != nil { |
|||
return fmt.Errorf("could not parse %s as int64 slice value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
} |
|||
if f.Value == nil { |
|||
f.Value = newVal |
|||
} else { |
|||
*f.Value = *newVal |
|||
} |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Value == nil { |
|||
f.Value = &Int64Slice{} |
|||
} |
|||
set.Var(f.Value, name, f.Usage) |
|||
}) |
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f BoolFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f BoolFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
val := false |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
if envVal == "" { |
|||
val = false |
|||
} else { |
|||
envValBool, err := strconv.ParseBool(envVal) |
|||
if err != nil { |
|||
return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
val = envValBool |
|||
} |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.BoolVar(f.Destination, name, val, f.Usage) |
|||
return |
|||
} |
|||
set.Bool(name, val, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f BoolTFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f BoolTFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
val := true |
|||
|
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
if envVal == "" { |
|||
val = false |
|||
} else { |
|||
envValBool, err := strconv.ParseBool(envVal) |
|||
if err != nil { |
|||
return fmt.Errorf("could not parse %s as bool value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
val = envValBool |
|||
} |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.BoolVar(f.Destination, name, val, f.Usage) |
|||
return |
|||
} |
|||
set.Bool(name, val, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f StringFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f StringFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
f.Value = envVal |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.StringVar(f.Destination, name, f.Value, f.Usage) |
|||
return |
|||
} |
|||
set.String(name, f.Value, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f IntFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f IntFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
envValInt, err := strconv.ParseInt(envVal, 0, 64) |
|||
if err != nil { |
|||
return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
f.Value = int(envValInt) |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.IntVar(f.Destination, name, f.Value, f.Usage) |
|||
return |
|||
} |
|||
set.Int(name, f.Value, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f Int64Flag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f Int64Flag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
envValInt, err := strconv.ParseInt(envVal, 0, 64) |
|||
if err != nil { |
|||
return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
|
|||
f.Value = envValInt |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.Int64Var(f.Destination, name, f.Value, f.Usage) |
|||
return |
|||
} |
|||
set.Int64(name, f.Value, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f UintFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f UintFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
envValInt, err := strconv.ParseUint(envVal, 0, 64) |
|||
if err != nil { |
|||
return fmt.Errorf("could not parse %s as uint value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
|
|||
f.Value = uint(envValInt) |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.UintVar(f.Destination, name, f.Value, f.Usage) |
|||
return |
|||
} |
|||
set.Uint(name, f.Value, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f Uint64Flag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f Uint64Flag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
envValInt, err := strconv.ParseUint(envVal, 0, 64) |
|||
if err != nil { |
|||
return fmt.Errorf("could not parse %s as uint64 value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
|
|||
f.Value = uint64(envValInt) |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.Uint64Var(f.Destination, name, f.Value, f.Usage) |
|||
return |
|||
} |
|||
set.Uint64(name, f.Value, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f DurationFlag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f DurationFlag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
envValDuration, err := time.ParseDuration(envVal) |
|||
if err != nil { |
|||
return fmt.Errorf("could not parse %s as duration for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
|
|||
f.Value = envValDuration |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.DurationVar(f.Destination, name, f.Value, f.Usage) |
|||
return |
|||
} |
|||
set.Duration(name, f.Value, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
// Apply populates the flag given the flag set and environment
|
|||
// Ignores errors
|
|||
func (f Float64Flag) Apply(set *flag.FlagSet) { |
|||
f.ApplyWithError(set) |
|||
} |
|||
|
|||
// ApplyWithError populates the flag given the flag set and environment
|
|||
func (f Float64Flag) ApplyWithError(set *flag.FlagSet) error { |
|||
if envVal, ok := flagFromFileEnv(f.FilePath, f.EnvVar); ok { |
|||
envValFloat, err := strconv.ParseFloat(envVal, 10) |
|||
if err != nil { |
|||
return fmt.Errorf("could not parse %s as float64 value for flag %s: %s", envVal, f.Name, err) |
|||
} |
|||
|
|||
f.Value = float64(envValFloat) |
|||
} |
|||
|
|||
eachName(f.Name, func(name string) { |
|||
if f.Destination != nil { |
|||
set.Float64Var(f.Destination, name, f.Value, f.Usage) |
|||
return |
|||
} |
|||
set.Float64(name, f.Value, f.Usage) |
|||
}) |
|||
|
|||
return nil |
|||
} |
|||
|
|||
func visibleFlags(fl []Flag) []Flag { |
|||
visible := []Flag{} |
|||
for _, flag := range fl { |
|||
field := flagValue(flag).FieldByName("Hidden") |
|||
if !field.IsValid() || !field.Bool() { |
|||
visible = append(visible, flag) |
|||
} |
|||
} |
|||
return visible |
|||
} |
|||
|
|||
func prefixFor(name string) (prefix string) { |
|||
if len(name) == 1 { |
|||
prefix = "-" |
|||
} else { |
|||
prefix = "--" |
|||
} |
|||
|
|||
return |
|||
} |
|||
|
|||
// Returns the placeholder, if any, and the unquoted usage string.
|
|||
func unquoteUsage(usage string) (string, string) { |
|||
for i := 0; i < len(usage); i++ { |
|||
if usage[i] == '`' { |
|||
for j := i + 1; j < len(usage); j++ { |
|||
if usage[j] == '`' { |
|||
name := usage[i+1 : j] |
|||
usage = usage[:i] + name + usage[j+1:] |
|||
return name, usage |
|||
} |
|||
} |
|||
break |
|||
} |
|||
} |
|||
return "", usage |
|||
} |
|||
|
|||
func prefixedNames(fullName, placeholder string) string { |
|||
var prefixed string |
|||
parts := strings.Split(fullName, ",") |
|||
for i, name := range parts { |
|||
name = strings.Trim(name, " ") |
|||
prefixed += prefixFor(name) + name |
|||
if placeholder != "" { |
|||
prefixed += " " + placeholder |
|||
} |
|||
if i < len(parts)-1 { |
|||
prefixed += ", " |
|||
} |
|||
} |
|||
return prefixed |
|||
} |
|||
|
|||
func withEnvHint(envVar, str string) string { |
|||
envText := "" |
|||
if envVar != "" { |
|||
prefix := "$" |
|||
suffix := "" |
|||
sep := ", $" |
|||
if runtime.GOOS == "windows" { |
|||
prefix = "%" |
|||
suffix = "%" |
|||
sep = "%, %" |
|||
} |
|||
envText = " [" + prefix + strings.Join(strings.Split(envVar, ","), sep) + suffix + "]" |
|||
} |
|||
return str + envText |
|||
} |
|||
|
|||
func withFileHint(filePath, str string) string { |
|||
fileText := "" |
|||
if filePath != "" { |
|||
fileText = fmt.Sprintf(" [%s]", filePath) |
|||
} |
|||
return str + fileText |
|||
} |
|||
|
|||
func flagValue(f Flag) reflect.Value { |
|||
fv := reflect.ValueOf(f) |
|||
for fv.Kind() == reflect.Ptr { |
|||
fv = reflect.Indirect(fv) |
|||
} |
|||
return fv |
|||
} |
|||
|
|||
func stringifyFlag(f Flag) string { |
|||
fv := flagValue(f) |
|||
|
|||
switch f.(type) { |
|||
case IntSliceFlag: |
|||
return FlagFileHinter( |
|||
fv.FieldByName("FilePath").String(), |
|||
FlagEnvHinter( |
|||
fv.FieldByName("EnvVar").String(), |
|||
stringifyIntSliceFlag(f.(IntSliceFlag)), |
|||
), |
|||
) |
|||
case Int64SliceFlag: |
|||
return FlagFileHinter( |
|||
fv.FieldByName("FilePath").String(), |
|||
FlagEnvHinter( |
|||
fv.FieldByName("EnvVar").String(), |
|||
stringifyInt64SliceFlag(f.(Int64SliceFlag)), |
|||
), |
|||
) |
|||
case StringSliceFlag: |
|||
return FlagFileHinter( |
|||
fv.FieldByName("FilePath").String(), |
|||
FlagEnvHinter( |
|||
fv.FieldByName("EnvVar").String(), |
|||
stringifyStringSliceFlag(f.(StringSliceFlag)), |
|||
), |
|||
) |
|||
} |
|||
|
|||
placeholder, usage := unquoteUsage(fv.FieldByName("Usage").String()) |
|||
|
|||
needsPlaceholder := false |
|||
defaultValueString := "" |
|||
|
|||
if val := fv.FieldByName("Value"); val.IsValid() { |
|||
needsPlaceholder = true |
|||
defaultValueString = fmt.Sprintf(" (default: %v)", val.Interface()) |
|||
|
|||
if val.Kind() == reflect.String && val.String() != "" { |
|||
defaultValueString = fmt.Sprintf(" (default: %q)", val.String()) |
|||
} |
|||
} |
|||
|
|||
if defaultValueString == " (default: )" { |
|||
defaultValueString = "" |
|||
} |
|||
|
|||
if needsPlaceholder && placeholder == "" { |
|||
placeholder = defaultPlaceholder |
|||
} |
|||
|
|||
usageWithDefault := strings.TrimSpace(usage + defaultValueString) |
|||
|
|||
return FlagFileHinter( |
|||
fv.FieldByName("FilePath").String(), |
|||
FlagEnvHinter( |
|||
fv.FieldByName("EnvVar").String(), |
|||
FlagNamePrefixer(fv.FieldByName("Name").String(), placeholder)+"\t"+usageWithDefault, |
|||
), |
|||
) |
|||
} |
|||
|
|||
func stringifyIntSliceFlag(f IntSliceFlag) string { |
|||
defaultVals := []string{} |
|||
if f.Value != nil && len(f.Value.Value()) > 0 { |
|||
for _, i := range f.Value.Value() { |
|||
defaultVals = append(defaultVals, strconv.Itoa(i)) |
|||
} |
|||
} |
|||
|
|||
return stringifySliceFlag(f.Usage, f.Name, defaultVals) |
|||
} |
|||
|
|||
func stringifyInt64SliceFlag(f Int64SliceFlag) string { |
|||
defaultVals := []string{} |
|||
if f.Value != nil && len(f.Value.Value()) > 0 { |
|||
for _, i := range f.Value.Value() { |
|||
defaultVals = append(defaultVals, strconv.FormatInt(i, 10)) |
|||
} |
|||
} |
|||
|
|||
return stringifySliceFlag(f.Usage, f.Name, defaultVals) |
|||
} |
|||
|
|||
func stringifyStringSliceFlag(f StringSliceFlag) string { |
|||
defaultVals := []string{} |
|||
if f.Value != nil && len(f.Value.Value()) > 0 { |
|||
for _, s := range f.Value.Value() { |
|||
if len(s) > 0 { |
|||
defaultVals = append(defaultVals, strconv.Quote(s)) |
|||
} |
|||
} |
|||
} |
|||
|
|||
return stringifySliceFlag(f.Usage, f.Name, defaultVals) |
|||
} |
|||
|
|||
func stringifySliceFlag(usage, name string, defaultVals []string) string { |
|||
placeholder, usage := unquoteUsage(usage) |
|||
if placeholder == "" { |
|||
placeholder = defaultPlaceholder |
|||
} |
|||
|
|||
defaultVal := "" |
|||
if len(defaultVals) > 0 { |
|||
defaultVal = fmt.Sprintf(" (default: %s)", strings.Join(defaultVals, ", ")) |
|||
} |
|||
|
|||
usageWithDefault := strings.TrimSpace(usage + defaultVal) |
|||
return FlagNamePrefixer(name, placeholder) + "\t" + usageWithDefault |
|||
} |
|||
|
|||
func flagFromFileEnv(filePath, envName string) (val string, ok bool) { |
|||
for _, envVar := range strings.Split(envName, ",") { |
|||
envVar = strings.TrimSpace(envVar) |
|||
if envVal, ok := syscall.Getenv(envVar); ok { |
|||
return envVal, true |
|||
} |
|||
} |
|||
for _, fileVar := range strings.Split(filePath, ",") { |
|||
if data, err := ioutil.ReadFile(fileVar); err == nil { |
|||
return string(data), true |
|||
} |
|||
} |
|||
return "", false |
|||
} |
|||
@ -0,0 +1,640 @@ |
|||
package cli |
|||
|
|||
import ( |
|||
"flag" |
|||
"strconv" |
|||
"time" |
|||
) |
|||
|
|||
// WARNING: This file is generated!
|
|||
|
|||
// BoolFlag is a flag with type bool
|
|||
type BoolFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Destination *bool |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f BoolFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f BoolFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Bool looks up the value of a local BoolFlag, returns
|
|||
// false if not found
|
|||
func (c *Context) Bool(name string) bool { |
|||
return lookupBool(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalBool looks up the value of a global BoolFlag, returns
|
|||
// false if not found
|
|||
func (c *Context) GlobalBool(name string) bool { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupBool(name, fs) |
|||
} |
|||
return false |
|||
} |
|||
|
|||
func lookupBool(name string, set *flag.FlagSet) bool { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := strconv.ParseBool(f.Value.String()) |
|||
if err != nil { |
|||
return false |
|||
} |
|||
return parsed |
|||
} |
|||
return false |
|||
} |
|||
|
|||
// BoolTFlag is a flag with type bool that is true by default
|
|||
type BoolTFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Destination *bool |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f BoolTFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f BoolTFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// BoolT looks up the value of a local BoolTFlag, returns
|
|||
// false if not found
|
|||
func (c *Context) BoolT(name string) bool { |
|||
return lookupBoolT(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalBoolT looks up the value of a global BoolTFlag, returns
|
|||
// false if not found
|
|||
func (c *Context) GlobalBoolT(name string) bool { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupBoolT(name, fs) |
|||
} |
|||
return false |
|||
} |
|||
|
|||
func lookupBoolT(name string, set *flag.FlagSet) bool { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := strconv.ParseBool(f.Value.String()) |
|||
if err != nil { |
|||
return false |
|||
} |
|||
return parsed |
|||
} |
|||
return false |
|||
} |
|||
|
|||
// DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration)
|
|||
type DurationFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value time.Duration |
|||
Destination *time.Duration |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f DurationFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f DurationFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Duration looks up the value of a local DurationFlag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) Duration(name string) time.Duration { |
|||
return lookupDuration(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalDuration looks up the value of a global DurationFlag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) GlobalDuration(name string) time.Duration { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupDuration(name, fs) |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
func lookupDuration(name string, set *flag.FlagSet) time.Duration { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := time.ParseDuration(f.Value.String()) |
|||
if err != nil { |
|||
return 0 |
|||
} |
|||
return parsed |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
// Float64Flag is a flag with type float64
|
|||
type Float64Flag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value float64 |
|||
Destination *float64 |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f Float64Flag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f Float64Flag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Float64 looks up the value of a local Float64Flag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) Float64(name string) float64 { |
|||
return lookupFloat64(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalFloat64 looks up the value of a global Float64Flag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) GlobalFloat64(name string) float64 { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupFloat64(name, fs) |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
func lookupFloat64(name string, set *flag.FlagSet) float64 { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := strconv.ParseFloat(f.Value.String(), 64) |
|||
if err != nil { |
|||
return 0 |
|||
} |
|||
return parsed |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
// GenericFlag is a flag with type Generic
|
|||
type GenericFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value Generic |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f GenericFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f GenericFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Generic looks up the value of a local GenericFlag, returns
|
|||
// nil if not found
|
|||
func (c *Context) Generic(name string) interface{} { |
|||
return lookupGeneric(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalGeneric looks up the value of a global GenericFlag, returns
|
|||
// nil if not found
|
|||
func (c *Context) GlobalGeneric(name string) interface{} { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupGeneric(name, fs) |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
func lookupGeneric(name string, set *flag.FlagSet) interface{} { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := f.Value, error(nil) |
|||
if err != nil { |
|||
return nil |
|||
} |
|||
return parsed |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
// Int64Flag is a flag with type int64
|
|||
type Int64Flag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value int64 |
|||
Destination *int64 |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f Int64Flag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f Int64Flag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Int64 looks up the value of a local Int64Flag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) Int64(name string) int64 { |
|||
return lookupInt64(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalInt64 looks up the value of a global Int64Flag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) GlobalInt64(name string) int64 { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupInt64(name, fs) |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
func lookupInt64(name string, set *flag.FlagSet) int64 { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := strconv.ParseInt(f.Value.String(), 0, 64) |
|||
if err != nil { |
|||
return 0 |
|||
} |
|||
return parsed |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
// IntFlag is a flag with type int
|
|||
type IntFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value int |
|||
Destination *int |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f IntFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f IntFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Int looks up the value of a local IntFlag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) Int(name string) int { |
|||
return lookupInt(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalInt looks up the value of a global IntFlag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) GlobalInt(name string) int { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupInt(name, fs) |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
func lookupInt(name string, set *flag.FlagSet) int { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := strconv.ParseInt(f.Value.String(), 0, 64) |
|||
if err != nil { |
|||
return 0 |
|||
} |
|||
return int(parsed) |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
// IntSliceFlag is a flag with type *IntSlice
|
|||
type IntSliceFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value *IntSlice |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f IntSliceFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f IntSliceFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// IntSlice looks up the value of a local IntSliceFlag, returns
|
|||
// nil if not found
|
|||
func (c *Context) IntSlice(name string) []int { |
|||
return lookupIntSlice(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalIntSlice looks up the value of a global IntSliceFlag, returns
|
|||
// nil if not found
|
|||
func (c *Context) GlobalIntSlice(name string) []int { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupIntSlice(name, fs) |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
func lookupIntSlice(name string, set *flag.FlagSet) []int { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := (f.Value.(*IntSlice)).Value(), error(nil) |
|||
if err != nil { |
|||
return nil |
|||
} |
|||
return parsed |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
// Int64SliceFlag is a flag with type *Int64Slice
|
|||
type Int64SliceFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value *Int64Slice |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f Int64SliceFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f Int64SliceFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Int64Slice looks up the value of a local Int64SliceFlag, returns
|
|||
// nil if not found
|
|||
func (c *Context) Int64Slice(name string) []int64 { |
|||
return lookupInt64Slice(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalInt64Slice looks up the value of a global Int64SliceFlag, returns
|
|||
// nil if not found
|
|||
func (c *Context) GlobalInt64Slice(name string) []int64 { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupInt64Slice(name, fs) |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
func lookupInt64Slice(name string, set *flag.FlagSet) []int64 { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := (f.Value.(*Int64Slice)).Value(), error(nil) |
|||
if err != nil { |
|||
return nil |
|||
} |
|||
return parsed |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
// StringFlag is a flag with type string
|
|||
type StringFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value string |
|||
Destination *string |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f StringFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f StringFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// String looks up the value of a local StringFlag, returns
|
|||
// "" if not found
|
|||
func (c *Context) String(name string) string { |
|||
return lookupString(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalString looks up the value of a global StringFlag, returns
|
|||
// "" if not found
|
|||
func (c *Context) GlobalString(name string) string { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupString(name, fs) |
|||
} |
|||
return "" |
|||
} |
|||
|
|||
func lookupString(name string, set *flag.FlagSet) string { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := f.Value.String(), error(nil) |
|||
if err != nil { |
|||
return "" |
|||
} |
|||
return parsed |
|||
} |
|||
return "" |
|||
} |
|||
|
|||
// StringSliceFlag is a flag with type *StringSlice
|
|||
type StringSliceFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value *StringSlice |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f StringSliceFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f StringSliceFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// StringSlice looks up the value of a local StringSliceFlag, returns
|
|||
// nil if not found
|
|||
func (c *Context) StringSlice(name string) []string { |
|||
return lookupStringSlice(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalStringSlice looks up the value of a global StringSliceFlag, returns
|
|||
// nil if not found
|
|||
func (c *Context) GlobalStringSlice(name string) []string { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupStringSlice(name, fs) |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
func lookupStringSlice(name string, set *flag.FlagSet) []string { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := (f.Value.(*StringSlice)).Value(), error(nil) |
|||
if err != nil { |
|||
return nil |
|||
} |
|||
return parsed |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
// Uint64Flag is a flag with type uint64
|
|||
type Uint64Flag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value uint64 |
|||
Destination *uint64 |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f Uint64Flag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f Uint64Flag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Uint64 looks up the value of a local Uint64Flag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) Uint64(name string) uint64 { |
|||
return lookupUint64(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalUint64 looks up the value of a global Uint64Flag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) GlobalUint64(name string) uint64 { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupUint64(name, fs) |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
func lookupUint64(name string, set *flag.FlagSet) uint64 { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := strconv.ParseUint(f.Value.String(), 0, 64) |
|||
if err != nil { |
|||
return 0 |
|||
} |
|||
return parsed |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
// UintFlag is a flag with type uint
|
|||
type UintFlag struct { |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
Value uint |
|||
Destination *uint |
|||
} |
|||
|
|||
// String returns a readable representation of this value
|
|||
// (for usage defaults)
|
|||
func (f UintFlag) String() string { |
|||
return FlagStringer(f) |
|||
} |
|||
|
|||
// GetName returns the name of the flag
|
|||
func (f UintFlag) GetName() string { |
|||
return f.Name |
|||
} |
|||
|
|||
// Uint looks up the value of a local UintFlag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) Uint(name string) uint { |
|||
return lookupUint(name, c.flagSet) |
|||
} |
|||
|
|||
// GlobalUint looks up the value of a global UintFlag, returns
|
|||
// 0 if not found
|
|||
func (c *Context) GlobalUint(name string) uint { |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil { |
|||
return lookupUint(name, fs) |
|||
} |
|||
return 0 |
|||
} |
|||
|
|||
func lookupUint(name string, set *flag.FlagSet) uint { |
|||
f := set.Lookup(name) |
|||
if f != nil { |
|||
parsed, err := strconv.ParseUint(f.Value.String(), 0, 64) |
|||
if err != nil { |
|||
return 0 |
|||
} |
|||
return uint(parsed) |
|||
} |
|||
return 0 |
|||
} |
|||
@ -0,0 +1,44 @@ |
|||
package cli |
|||
|
|||
// BashCompleteFunc is an action to execute when the bash-completion flag is set
|
|||
type BashCompleteFunc func(*Context) |
|||
|
|||
// BeforeFunc is an action to execute before any subcommands are run, but after
|
|||
// the context is ready if a non-nil error is returned, no subcommands are run
|
|||
type BeforeFunc func(*Context) error |
|||
|
|||
// AfterFunc is an action to execute after any subcommands are run, but after the
|
|||
// subcommand has finished it is run even if Action() panics
|
|||
type AfterFunc func(*Context) error |
|||
|
|||
// ActionFunc is the action to execute when no subcommands are specified
|
|||
type ActionFunc func(*Context) error |
|||
|
|||
// CommandNotFoundFunc is executed if the proper command cannot be found
|
|||
type CommandNotFoundFunc func(*Context, string) |
|||
|
|||
// OnUsageErrorFunc is executed if an usage error occurs. This is useful for displaying
|
|||
// customized usage error messages. This function is able to replace the
|
|||
// original error messages. If this function is not set, the "Incorrect usage"
|
|||
// is displayed and the execution is interrupted.
|
|||
type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error |
|||
|
|||
// ExitErrHandlerFunc is executed if provided in order to handle ExitError values
|
|||
// returned by Actions and Before/After functions.
|
|||
type ExitErrHandlerFunc func(context *Context, err error) |
|||
|
|||
// FlagStringFunc is used by the help generation to display a flag, which is
|
|||
// expected to be a single line.
|
|||
type FlagStringFunc func(Flag) string |
|||
|
|||
// FlagNamePrefixFunc is used by the default FlagStringFunc to create prefix
|
|||
// text for a flag's full name.
|
|||
type FlagNamePrefixFunc func(fullName, placeholder string) string |
|||
|
|||
// FlagEnvHintFunc is used by the default FlagStringFunc to annotate flag help
|
|||
// with the environment variable details.
|
|||
type FlagEnvHintFunc func(envVar, str string) string |
|||
|
|||
// FlagFileHintFunc is used by the default FlagStringFunc to annotate flag help
|
|||
// with the file path details.
|
|||
type FlagFileHintFunc func(filePath, str string) string |
|||
@ -0,0 +1,256 @@ |
|||
#!/usr/bin/env python |
|||
""" |
|||
The flag types that ship with the cli library have many things in common, and |
|||
so we can take advantage of the `go generate` command to create much of the |
|||
source code from a list of definitions. These definitions attempt to cover |
|||
the parts that vary between flag types, and should evolve as needed. |
|||
|
|||
An example of the minimum definition needed is: |
|||
|
|||
{ |
|||
"name": "SomeType", |
|||
"type": "sometype", |
|||
"context_default": "nil" |
|||
} |
|||
|
|||
In this example, the code generated for the `cli` package will include a type |
|||
named `SomeTypeFlag` that is expected to wrap a value of type `sometype`. |
|||
Fetching values by name via `*cli.Context` will default to a value of `nil`. |
|||
|
|||
A more complete, albeit somewhat redundant, example showing all available |
|||
definition keys is: |
|||
|
|||
{ |
|||
"name": "VeryMuchType", |
|||
"type": "*VeryMuchType", |
|||
"value": true, |
|||
"dest": false, |
|||
"doctail": " which really only wraps a []float64, oh well!", |
|||
"context_type": "[]float64", |
|||
"context_default": "nil", |
|||
"parser": "parseVeryMuchType(f.Value.String())", |
|||
"parser_cast": "[]float64(parsed)" |
|||
} |
|||
|
|||
The meaning of each field is as follows: |
|||
|
|||
name (string) - The type "name", which will be suffixed with |
|||
`Flag` when generating the type definition |
|||
for `cli` and the wrapper type for `altsrc` |
|||
type (string) - The type that the generated `Flag` type for `cli` |
|||
is expected to "contain" as its `.Value` member |
|||
value (bool) - Should the generated `cli` type have a `Value` |
|||
member? |
|||
dest (bool) - Should the generated `cli` type support a |
|||
destination pointer? |
|||
doctail (string) - Additional docs for the `cli` flag type comment |
|||
context_type (string) - The literal type used in the `*cli.Context` |
|||
reader func signature |
|||
context_default (string) - The literal value used as the default by the |
|||
`*cli.Context` reader funcs when no value is |
|||
present |
|||
parser (string) - Literal code used to parse the flag `f`, |
|||
expected to have a return signature of |
|||
(value, error) |
|||
parser_cast (string) - Literal code used to cast the `parsed` value |
|||
returned from the `parser` code |
|||
""" |
|||
|
|||
from __future__ import print_function, unicode_literals |
|||
|
|||
import argparse |
|||
import json |
|||
import os |
|||
import subprocess |
|||
import sys |
|||
import tempfile |
|||
import textwrap |
|||
|
|||
|
|||
class _FancyFormatter(argparse.ArgumentDefaultsHelpFormatter, |
|||
argparse.RawDescriptionHelpFormatter): |
|||
pass |
|||
|
|||
|
|||
def main(sysargs=sys.argv[:]): |
|||
parser = argparse.ArgumentParser( |
|||
description='Generate flag type code!', |
|||
formatter_class=_FancyFormatter) |
|||
parser.add_argument( |
|||
'package', |
|||
type=str, default='cli', choices=_WRITEFUNCS.keys(), |
|||
help='Package for which flag types will be generated' |
|||
) |
|||
parser.add_argument( |
|||
'-i', '--in-json', |
|||
type=argparse.FileType('r'), |
|||
default=sys.stdin, |
|||
help='Input JSON file which defines each type to be generated' |
|||
) |
|||
parser.add_argument( |
|||
'-o', '--out-go', |
|||
type=argparse.FileType('w'), |
|||
default=sys.stdout, |
|||
help='Output file/stream to which generated source will be written' |
|||
) |
|||
parser.epilog = __doc__ |
|||
|
|||
args = parser.parse_args(sysargs[1:]) |
|||
_generate_flag_types(_WRITEFUNCS[args.package], args.out_go, args.in_json) |
|||
return 0 |
|||
|
|||
|
|||
def _generate_flag_types(writefunc, output_go, input_json): |
|||
types = json.load(input_json) |
|||
|
|||
tmp = tempfile.NamedTemporaryFile(suffix='.go', delete=False) |
|||
writefunc(tmp, types) |
|||
tmp.close() |
|||
|
|||
new_content = subprocess.check_output( |
|||
['goimports', tmp.name] |
|||
).decode('utf-8') |
|||
|
|||
print(new_content, file=output_go, end='') |
|||
output_go.flush() |
|||
os.remove(tmp.name) |
|||
|
|||
|
|||
def _set_typedef_defaults(typedef): |
|||
typedef.setdefault('doctail', '') |
|||
typedef.setdefault('context_type', typedef['type']) |
|||
typedef.setdefault('dest', True) |
|||
typedef.setdefault('value', True) |
|||
typedef.setdefault('parser', 'f.Value, error(nil)') |
|||
typedef.setdefault('parser_cast', 'parsed') |
|||
|
|||
|
|||
def _write_cli_flag_types(outfile, types): |
|||
_fwrite(outfile, """\ |
|||
package cli |
|||
|
|||
// WARNING: This file is generated! |
|||
|
|||
""") |
|||
|
|||
for typedef in types: |
|||
_set_typedef_defaults(typedef) |
|||
|
|||
_fwrite(outfile, """\ |
|||
// {name}Flag is a flag with type {type}{doctail} |
|||
type {name}Flag struct {{ |
|||
Name string |
|||
Usage string |
|||
EnvVar string |
|||
FilePath string |
|||
Hidden bool |
|||
""".format(**typedef)) |
|||
|
|||
if typedef['value']: |
|||
_fwrite(outfile, """\ |
|||
Value {type} |
|||
""".format(**typedef)) |
|||
|
|||
if typedef['dest']: |
|||
_fwrite(outfile, """\ |
|||
Destination *{type} |
|||
""".format(**typedef)) |
|||
|
|||
_fwrite(outfile, "\n}\n\n") |
|||
|
|||
_fwrite(outfile, """\ |
|||
// String returns a readable representation of this value |
|||
// (for usage defaults) |
|||
func (f {name}Flag) String() string {{ |
|||
return FlagStringer(f) |
|||
}} |
|||
|
|||
// GetName returns the name of the flag |
|||
func (f {name}Flag) GetName() string {{ |
|||
return f.Name |
|||
}} |
|||
|
|||
// {name} looks up the value of a local {name}Flag, returns |
|||
// {context_default} if not found |
|||
func (c *Context) {name}(name string) {context_type} {{ |
|||
return lookup{name}(name, c.flagSet) |
|||
}} |
|||
|
|||
// Global{name} looks up the value of a global {name}Flag, returns |
|||
// {context_default} if not found |
|||
func (c *Context) Global{name}(name string) {context_type} {{ |
|||
if fs := lookupGlobalFlagSet(name, c); fs != nil {{ |
|||
return lookup{name}(name, fs) |
|||
}} |
|||
return {context_default} |
|||
}} |
|||
|
|||
func lookup{name}(name string, set *flag.FlagSet) {context_type} {{ |
|||
f := set.Lookup(name) |
|||
if f != nil {{ |
|||
parsed, err := {parser} |
|||
if err != nil {{ |
|||
return {context_default} |
|||
}} |
|||
return {parser_cast} |
|||
}} |
|||
return {context_default} |
|||
}} |
|||
""".format(**typedef)) |
|||
|
|||
|
|||
def _write_altsrc_flag_types(outfile, types): |
|||
_fwrite(outfile, """\ |
|||
package altsrc |
|||
|
|||
import ( |
|||
"gopkg.in/urfave/cli.v1" |
|||
) |
|||
|
|||
// WARNING: This file is generated! |
|||
|
|||
""") |
|||
|
|||
for typedef in types: |
|||
_set_typedef_defaults(typedef) |
|||
|
|||
_fwrite(outfile, """\ |
|||
// {name}Flag is the flag type that wraps cli.{name}Flag to allow |
|||
// for other values to be specified |
|||
type {name}Flag struct {{ |
|||
cli.{name}Flag |
|||
set *flag.FlagSet |
|||
}} |
|||
|
|||
// New{name}Flag creates a new {name}Flag |
|||
func New{name}Flag(fl cli.{name}Flag) *{name}Flag {{ |
|||
return &{name}Flag{{{name}Flag: fl, set: nil}} |
|||
}} |
|||
|
|||
// Apply saves the flagSet for later usage calls, then calls the |
|||
// wrapped {name}Flag.Apply |
|||
func (f *{name}Flag) Apply(set *flag.FlagSet) {{ |
|||
f.set = set |
|||
f.{name}Flag.Apply(set) |
|||
}} |
|||
|
|||
// ApplyWithError saves the flagSet for later usage calls, then calls the |
|||
// wrapped {name}Flag.ApplyWithError |
|||
func (f *{name}Flag) ApplyWithError(set *flag.FlagSet) error {{ |
|||
f.set = set |
|||
return f.{name}Flag.ApplyWithError(set) |
|||
}} |
|||
""".format(**typedef)) |
|||
|
|||
|
|||
def _fwrite(outfile, text): |
|||
print(textwrap.dedent(text), end='', file=outfile) |
|||
|
|||
|
|||
_WRITEFUNCS = { |
|||
'cli': _write_cli_flag_types, |
|||
'altsrc': _write_altsrc_flag_types |
|||
} |
|||
|
|||
if __name__ == '__main__': |
|||
sys.exit(main()) |
|||
@ -0,0 +1,345 @@ |
|||
package cli |
|||
|
|||
import ( |
|||
"fmt" |
|||
"io" |
|||
"os" |
|||
"strings" |
|||
"text/tabwriter" |
|||
"text/template" |
|||
) |
|||
|
|||
// AppHelpTemplate is the text template for the Default help topic.
|
|||
// cli.go uses text/template to render templates. You can
|
|||
// render custom help text by setting this variable.
|
|||
var AppHelpTemplate = `NAME: |
|||
{{.Name}}{{if .Usage}} - {{.Usage}}{{end}} |
|||
|
|||
USAGE: |
|||
{{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Version}}{{if not .HideVersion}} |
|||
|
|||
VERSION: |
|||
{{.Version}}{{end}}{{end}}{{if .Description}} |
|||
|
|||
DESCRIPTION: |
|||
{{.Description}}{{end}}{{if len .Authors}} |
|||
|
|||
AUTHOR{{with $length := len .Authors}}{{if ne 1 $length}}S{{end}}{{end}}: |
|||
{{range $index, $author := .Authors}}{{if $index}} |
|||
{{end}}{{$author}}{{end}}{{end}}{{if .VisibleCommands}} |
|||
|
|||
COMMANDS:{{range .VisibleCategories}}{{if .Name}} |
|||
|
|||
{{.Name}}:{{end}}{{range .VisibleCommands}} |
|||
{{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{end}}{{end}}{{if .VisibleFlags}} |
|||
|
|||
GLOBAL OPTIONS: |
|||
{{range $index, $option := .VisibleFlags}}{{if $index}} |
|||
{{end}}{{$option}}{{end}}{{end}}{{if .Copyright}} |
|||
|
|||
COPYRIGHT: |
|||
{{.Copyright}}{{end}} |
|||
` |
|||
|
|||
// CommandHelpTemplate is 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.
|
|||
var CommandHelpTemplate = `NAME: |
|||
{{.HelpName}} - {{.Usage}} |
|||
|
|||
USAGE: |
|||
{{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Category}} |
|||
|
|||
CATEGORY: |
|||
{{.Category}}{{end}}{{if .Description}} |
|||
|
|||
DESCRIPTION: |
|||
{{.Description}}{{end}}{{if .VisibleFlags}} |
|||
|
|||
OPTIONS: |
|||
{{range .VisibleFlags}}{{.}} |
|||
{{end}}{{end}} |
|||
` |
|||
|
|||
// SubcommandHelpTemplate is the text template for the subcommand help topic.
|
|||
// cli.go uses text/template to render templates. You can
|
|||
// render custom help text by setting this variable.
|
|||
var SubcommandHelpTemplate = `NAME: |
|||
{{.HelpName}} - {{if .Description}}{{.Description}}{{else}}{{.Usage}}{{end}} |
|||
|
|||
USAGE: |
|||
{{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} command{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}} |
|||
|
|||
COMMANDS:{{range .VisibleCategories}}{{if .Name}} |
|||
{{.Name}}:{{end}}{{range .VisibleCommands}} |
|||
{{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}} |
|||
{{end}}{{if .VisibleFlags}} |
|||
OPTIONS: |
|||
{{range .VisibleFlags}}{{.}} |
|||
{{end}}{{end}} |
|||
` |
|||
|
|||
var helpCommand = Command{ |
|||
Name: "help", |
|||
Aliases: []string{"h"}, |
|||
Usage: "Shows a list of commands or help for one command", |
|||
ArgsUsage: "[command]", |
|||
Action: func(c *Context) error { |
|||
args := c.Args() |
|||
if args.Present() { |
|||
return ShowCommandHelp(c, args.First()) |
|||
} |
|||
|
|||
ShowAppHelp(c) |
|||
return nil |
|||
}, |
|||
} |
|||
|
|||
var helpSubcommand = Command{ |
|||
Name: "help", |
|||
Aliases: []string{"h"}, |
|||
Usage: "Shows a list of commands or help for one command", |
|||
ArgsUsage: "[command]", |
|||
Action: func(c *Context) error { |
|||
args := c.Args() |
|||
if args.Present() { |
|||
return ShowCommandHelp(c, args.First()) |
|||
} |
|||
|
|||
return ShowSubcommandHelp(c) |
|||
}, |
|||
} |
|||
|
|||
// Prints help for the App or Command
|
|||
type helpPrinter func(w io.Writer, templ string, data interface{}) |
|||
|
|||
// Prints help for the App or Command with custom template function.
|
|||
type helpPrinterCustom func(w io.Writer, templ string, data interface{}, customFunc map[string]interface{}) |
|||
|
|||
// HelpPrinter is a function that writes the help output. If not set a default
|
|||
// is used. The function signature is:
|
|||
// func(w io.Writer, templ string, data interface{})
|
|||
var HelpPrinter helpPrinter = printHelp |
|||
|
|||
// HelpPrinterCustom is same as HelpPrinter but
|
|||
// takes a custom function for template function map.
|
|||
var HelpPrinterCustom helpPrinterCustom = printHelpCustom |
|||
|
|||
// VersionPrinter prints the version for the App
|
|||
var VersionPrinter = printVersion |
|||
|
|||
// ShowAppHelpAndExit - Prints the list of subcommands for the app and exits with exit code.
|
|||
func ShowAppHelpAndExit(c *Context, exitCode int) { |
|||
ShowAppHelp(c) |
|||
os.Exit(exitCode) |
|||
} |
|||
|
|||
// ShowAppHelp is an action that displays the help.
|
|||
func ShowAppHelp(c *Context) (err error) { |
|||
if c.App.CustomAppHelpTemplate == "" { |
|||
HelpPrinter(c.App.Writer, AppHelpTemplate, c.App) |
|||
return |
|||
} |
|||
customAppData := func() map[string]interface{} { |
|||
if c.App.ExtraInfo == nil { |
|||
return nil |
|||
} |
|||
return map[string]interface{}{ |
|||
"ExtraInfo": c.App.ExtraInfo, |
|||
} |
|||
} |
|||
HelpPrinterCustom(c.App.Writer, c.App.CustomAppHelpTemplate, c.App, customAppData()) |
|||
return nil |
|||
} |
|||
|
|||
// DefaultAppComplete prints the list of subcommands as the default app completion method
|
|||
func DefaultAppComplete(c *Context) { |
|||
for _, command := range c.App.Commands { |
|||
if command.Hidden { |
|||
continue |
|||
} |
|||
if os.Getenv("_CLI_ZSH_AUTOCOMPLETE_HACK") == "1" { |
|||
for _, name := range command.Names() { |
|||
fmt.Fprintf(c.App.Writer, "%s:%s\n", name, command.Usage) |
|||
} |
|||
} else { |
|||
for _, name := range command.Names() { |
|||
fmt.Fprintf(c.App.Writer, "%s\n", name) |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
// ShowCommandHelpAndExit - exits with code after showing help
|
|||
func ShowCommandHelpAndExit(c *Context, command string, code int) { |
|||
ShowCommandHelp(c, command) |
|||
os.Exit(code) |
|||
} |
|||
|
|||
// ShowCommandHelp prints help for the given command
|
|||
func ShowCommandHelp(ctx *Context, command string) error { |
|||
// show the subcommand help for a command with subcommands
|
|||
if command == "" { |
|||
HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App) |
|||
return nil |
|||
} |
|||
|
|||
for _, c := range ctx.App.Commands { |
|||
if c.HasName(command) { |
|||
if c.CustomHelpTemplate != "" { |
|||
HelpPrinterCustom(ctx.App.Writer, c.CustomHelpTemplate, c, nil) |
|||
} else { |
|||
HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c) |
|||
} |
|||
return nil |
|||
} |
|||
} |
|||
|
|||
if ctx.App.CommandNotFound == nil { |
|||
return NewExitError(fmt.Sprintf("No help topic for '%v'", command), 3) |
|||
} |
|||
|
|||
ctx.App.CommandNotFound(ctx, command) |
|||
return nil |
|||
} |
|||
|
|||
// ShowSubcommandHelp prints help for the given subcommand
|
|||
func ShowSubcommandHelp(c *Context) error { |
|||
return ShowCommandHelp(c, c.Command.Name) |
|||
} |
|||
|
|||
// ShowVersion prints the version number of the App
|
|||
func ShowVersion(c *Context) { |
|||
VersionPrinter(c) |
|||
} |
|||
|
|||
func printVersion(c *Context) { |
|||
fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version) |
|||
} |
|||
|
|||
// ShowCompletions prints the lists of commands within a given context
|
|||
func ShowCompletions(c *Context) { |
|||
a := c.App |
|||
if a != nil && a.BashComplete != nil { |
|||
a.BashComplete(c) |
|||
} |
|||
} |
|||
|
|||
// ShowCommandCompletions prints the custom completions for a given command
|
|||
func ShowCommandCompletions(ctx *Context, command string) { |
|||
c := ctx.App.Command(command) |
|||
if c != nil && c.BashComplete != nil { |
|||
c.BashComplete(ctx) |
|||
} |
|||
} |
|||
|
|||
func printHelpCustom(out io.Writer, templ string, data interface{}, customFunc map[string]interface{}) { |
|||
funcMap := template.FuncMap{ |
|||
"join": strings.Join, |
|||
} |
|||
if customFunc != nil { |
|||
for key, value := range customFunc { |
|||
funcMap[key] = value |
|||
} |
|||
} |
|||
|
|||
w := tabwriter.NewWriter(out, 1, 8, 2, ' ', 0) |
|||
t := template.Must(template.New("help").Funcs(funcMap).Parse(templ)) |
|||
err := t.Execute(w, data) |
|||
if err != nil { |
|||
// If the writer is closed, t.Execute will fail, and there's nothing
|
|||
// we can do to recover.
|
|||
if os.Getenv("CLI_TEMPLATE_ERROR_DEBUG") != "" { |
|||
fmt.Fprintf(ErrWriter, "CLI TEMPLATE ERROR: %#v\n", err) |
|||
} |
|||
return |
|||
} |
|||
w.Flush() |
|||
} |
|||
|
|||
func printHelp(out io.Writer, templ string, data interface{}) { |
|||
printHelpCustom(out, templ, data, nil) |
|||
} |
|||
|
|||
func checkVersion(c *Context) bool { |
|||
found := false |
|||
if VersionFlag.GetName() != "" { |
|||
eachName(VersionFlag.GetName(), func(name string) { |
|||
if c.GlobalBool(name) || c.Bool(name) { |
|||
found = true |
|||
} |
|||
}) |
|||
} |
|||
return found |
|||
} |
|||
|
|||
func checkHelp(c *Context) bool { |
|||
found := false |
|||
if HelpFlag.GetName() != "" { |
|||
eachName(HelpFlag.GetName(), func(name string) { |
|||
if c.GlobalBool(name) || c.Bool(name) { |
|||
found = true |
|||
} |
|||
}) |
|||
} |
|||
return found |
|||
} |
|||
|
|||
func checkCommandHelp(c *Context, name string) bool { |
|||
if c.Bool("h") || c.Bool("help") { |
|||
ShowCommandHelp(c, name) |
|||
return true |
|||
} |
|||
|
|||
return false |
|||
} |
|||
|
|||
func checkSubcommandHelp(c *Context) bool { |
|||
if c.Bool("h") || c.Bool("help") { |
|||
ShowSubcommandHelp(c) |
|||
return true |
|||
} |
|||
|
|||
return false |
|||
} |
|||
|
|||
func checkShellCompleteFlag(a *App, arguments []string) (bool, []string) { |
|||
if !a.EnableBashCompletion { |
|||
return false, arguments |
|||
} |
|||
|
|||
pos := len(arguments) - 1 |
|||
lastArg := arguments[pos] |
|||
|
|||
if lastArg != "--"+BashCompletionFlag.GetName() { |
|||
return false, arguments |
|||
} |
|||
|
|||
return true, arguments[:pos] |
|||
} |
|||
|
|||
func checkCompletions(c *Context) bool { |
|||
if !c.shellComplete { |
|||
return false |
|||
} |
|||
|
|||
if args := c.Args(); args.Present() { |
|||
name := args.First() |
|||
if cmd := c.App.Command(name); cmd != nil { |
|||
// let the command handle the completion
|
|||
return false |
|||
} |
|||
} |
|||
|
|||
ShowCompletions(c) |
|||
return true |
|||
} |
|||
|
|||
func checkCommandCompletions(c *Context, name string) bool { |
|||
if !c.shellComplete { |
|||
return false |
|||
} |
|||
|
|||
ShowCommandCompletions(c, name) |
|||
return true |
|||
} |
|||
@ -0,0 +1,122 @@ |
|||
#!/usr/bin/env python |
|||
from __future__ import print_function |
|||
|
|||
import argparse |
|||
import os |
|||
import sys |
|||
import tempfile |
|||
|
|||
from subprocess import check_call, check_output |
|||
|
|||
|
|||
PACKAGE_NAME = os.environ.get( |
|||
'CLI_PACKAGE_NAME', 'github.com/urfave/cli' |
|||
) |
|||
|
|||
|
|||
def main(sysargs=sys.argv[:]): |
|||
targets = { |
|||
'vet': _vet, |
|||
'test': _test, |
|||
'gfmrun': _gfmrun, |
|||
'toc': _toc, |
|||
'gen': _gen, |
|||
} |
|||
|
|||
parser = argparse.ArgumentParser() |
|||
parser.add_argument( |
|||
'target', nargs='?', choices=tuple(targets.keys()), default='test' |
|||
) |
|||
args = parser.parse_args(sysargs[1:]) |
|||
|
|||
targets[args.target]() |
|||
return 0 |
|||
|
|||
|
|||
def _test(): |
|||
if check_output('go version'.split()).split()[2] < 'go1.2': |
|||
_run('go test -v .') |
|||
return |
|||
|
|||
coverprofiles = [] |
|||
for subpackage in ['', 'altsrc']: |
|||
coverprofile = 'cli.coverprofile' |
|||
if subpackage != '': |
|||
coverprofile = '{}.coverprofile'.format(subpackage) |
|||
|
|||
coverprofiles.append(coverprofile) |
|||
|
|||
_run('go test -v'.split() + [ |
|||
'-coverprofile={}'.format(coverprofile), |
|||
('{}/{}'.format(PACKAGE_NAME, subpackage)).rstrip('/') |
|||
]) |
|||
|
|||
combined_name = _combine_coverprofiles(coverprofiles) |
|||
_run('go tool cover -func={}'.format(combined_name)) |
|||
os.remove(combined_name) |
|||
|
|||
|
|||
def _gfmrun(): |
|||
go_version = check_output('go version'.split()).split()[2] |
|||
if go_version < 'go1.3': |
|||
print('runtests: skip on {}'.format(go_version), file=sys.stderr) |
|||
return |
|||
_run(['gfmrun', '-c', str(_gfmrun_count()), '-s', 'README.md']) |
|||
|
|||
|
|||
def _vet(): |
|||
_run('go vet ./...') |
|||
|
|||
|
|||
def _toc(): |
|||
_run('node_modules/.bin/markdown-toc -i README.md') |
|||
_run('git diff --exit-code') |
|||
|
|||
|
|||
def _gen(): |
|||
go_version = check_output('go version'.split()).split()[2] |
|||
if go_version < 'go1.5': |
|||
print('runtests: skip on {}'.format(go_version), file=sys.stderr) |
|||
return |
|||
|
|||
_run('go generate ./...') |
|||
_run('git diff --exit-code') |
|||
|
|||
|
|||
def _run(command): |
|||
if hasattr(command, 'split'): |
|||
command = command.split() |
|||
print('runtests: {}'.format(' '.join(command)), file=sys.stderr) |
|||
check_call(command) |
|||
|
|||
|
|||
def _gfmrun_count(): |
|||
with open('README.md') as infile: |
|||
lines = infile.read().splitlines() |
|||
return len(filter(_is_go_runnable, lines)) |
|||
|
|||
|
|||
def _is_go_runnable(line): |
|||
return line.startswith('package main') |
|||
|
|||
|
|||
def _combine_coverprofiles(coverprofiles): |
|||
combined = tempfile.NamedTemporaryFile( |
|||
suffix='.coverprofile', delete=False |
|||
) |
|||
combined.write('mode: set\n') |
|||
|
|||
for coverprofile in coverprofiles: |
|||
with open(coverprofile, 'r') as infile: |
|||
for line in infile.readlines(): |
|||
if not line.startswith('mode: '): |
|||
combined.write(line) |
|||
|
|||
combined.flush() |
|||
name = combined.name |
|||
combined.close() |
|||
return name |
|||
|
|||
|
|||
if __name__ == '__main__': |
|||
sys.exit(main()) |
|||
@ -0,0 +1,29 @@ |
|||
package cli |
|||
|
|||
import "unicode" |
|||
|
|||
// lexicographicLess compares strings alphabetically considering case.
|
|||
func lexicographicLess(i, j string) bool { |
|||
iRunes := []rune(i) |
|||
jRunes := []rune(j) |
|||
|
|||
lenShared := len(iRunes) |
|||
if lenShared > len(jRunes) { |
|||
lenShared = len(jRunes) |
|||
} |
|||
|
|||
for index := 0; index < lenShared; index++ { |
|||
ir := iRunes[index] |
|||
jr := jRunes[index] |
|||
|
|||
if lir, ljr := unicode.ToLower(ir), unicode.ToLower(jr); lir != ljr { |
|||
return lir < ljr |
|||
} |
|||
|
|||
if ir != jr { |
|||
return ir < jr |
|||
} |
|||
} |
|||
|
|||
return i < j |
|||
} |
|||
@ -0,0 +1,13 @@ |
|||
{ |
|||
"comment": "", |
|||
"ignore": "test", |
|||
"package": [ |
|||
{ |
|||
"checksumSHA1": "9/2qvuFPQxW7ZXzQSOYwqZb5cNg=", |
|||
"path": "github.com/urfave/cli", |
|||
"revision": "8e01ec4cd3e2d84ab2fe90d8210528ffbb06d8ff", |
|||
"revisionTime": "2018-02-26T03:02:53Z" |
|||
} |
|||
], |
|||
"rootPath": "github.com/appleboy/drone-packer" |
|||
} |
|||
Loading…
Reference in new issue