From c75fee9224817c00f1e2630c31aa5686a70f5fb8 Mon Sep 17 00:00:00 2001 From: Ajitem Sahasrabuddhe Date: Fri, 13 Sep 2019 04:56:14 +0530 Subject: [PATCH] Merge master @1.22.1 with v2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit commit c71fbcefd21552b70cd625b2c54466006e258ad7 Merge: 61f3ae3 ef47250 Author: Ajitem Sahasrabuddhe Date: Thu Sep 12 05:35:50 2019 +0530 Merge pull request #887 from urfave/asahasrabuddhe-patch-1 Release 1.22.1 commit ef47250cda5ff52a313118c01ad6b0c5b4877a70 Merge: 71eaf37 61f3ae3 Author: Ajitem Sahasrabuddhe Date: Thu Sep 12 05:19:58 2019 +0530 Merge branch 'master' into asahasrabuddhe-patch-1 commit 61f3ae353bf455e3522aff0d5a28be9278bba7f2 Merge: 388c2dd fa858dc Author: Ajitem Sahasrabuddhe Date: Thu Sep 12 05:19:33 2019 +0530 Merge pull request #890 from urfave/issue-878 Fix #878 commit fa858dcc260fb07c25aab13650d9fa0e64f851c7 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 15:10:14 2019 +0530 Ensure flag is not blank commit f8bb66ae7d679973cf9b3f6f8c3dc6933404a31a Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:42:38 2019 +0530 Fix Typo commit 056aef13fe0b0e51403036ca5527854f50a1f3cd Merge: c6ee3b4 82a84fc Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:37:06 2019 +0530 Merge branch 'issue-878' of https://github.com/urfave/cli into issue-878 commit c6ee3b4904ed76d34f277c315c2097ae7b22d38f Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:34:41 2019 +0530 Use iterative logic to determine missing flag commit 82a84fc187c23434a5c2e1398a7fcfbc9c51df94 Merge: 1547ac2 388c2dd Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:17:11 2019 +0530 Merge branch 'master' into issue-878 commit 1547ac2f6a3d3d39fe4d49570c0d1c2401a8f20e Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:15:20 2019 +0530 Modify variable names commit 388c2dd0f4ffaa8541e371d49c8413870a04d9fe Merge: e19126a 6d888d6 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:13:40 2019 +0530 Merge pull request #891 from saschagrunert/fish-hidden Don't generate fish completion for hidden commands commit 71eaf37e337d5daea12c6a137113c71056151530 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:09:50 2019 +0530 Update CHANGELOG.md commit 6d888d693d81e13806356854c57574334d9ef3b9 Merge: bac5bde e19126a Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:04:44 2019 +0530 Merge branch 'master' into fish-hidden commit e19126a8198a7c076339e69ed4d372567750dd24 Merge: b207e20 35eb598 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 14:01:44 2019 +0530 Merge pull request #883 from urfave/remove-flag-generation Remove flag generation commit bac5bde38c7725990645cf9b2bf2c824594f3963 Author: Sascha Grunert Date: Wed Sep 11 09:06:02 2019 +0200 Don't generate fish completion for hidden commands Added the missing test case as well. Signed-off-by: Sascha Grunert commit 36cdaa9964df03e2b8f8d2147a99497536851ad9 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 10:34:00 2019 +0530 Update CHANGELOG.md commit cbb9e015b89225aa090c41085bdb0933f6290d96 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 09:21:45 2019 +0530 Improve Code and Add Test Case commit 7d6a604106e44732edc0a76f4a4800c8c27ddfbe Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 08:59:51 2019 +0530 Fix #878 commit be37c2cbda3ba6a37fa8f7a0df960de844afc843 Merge: 0aee120 b207e20 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 08:27:45 2019 +0530 Merge branch 'master' into asahasrabuddhe-patch-1 commit 35eb598d43c3ab639e3c0ccc72e37f294e5b5828 Merge: 8575558 b207e20 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 05:39:35 2019 +0530 Merge branch 'master' into remove-flag-generation commit 0aee120c32003fff6f320c2a00a41d03285fdde0 Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 05:37:41 2019 +0530 Update CHANGELOG.md commit 5c019b10ca37c1a0b74b637d3b0aa25dfeb0110f Author: Ajitem Sahasrabuddhe Date: Wed Sep 11 05:33:46 2019 +0530 Update CHANGELOG.md commit b207e20873f5805e7c9cc544b3418a0a3ec63e09 Merge: 249cb33 487be14 Author: Audrius Butkevicius Date: Tue Sep 10 21:28:35 2019 +0100 Merge pull request #889 from crosbymichael/hidden-man Don't output hidden commands for man pages commit 487be14dceb185a3321cacd9bf302f5e811f5ee8 Author: Michael Crosby Date: Tue Sep 10 13:49:11 2019 -0400 Don't output hidden commands for man pages Signed-off-by: Michael Crosby commit 85755588ac06f74702bf7d62802dab0655881182 Merge: 024692c 249cb33 Author: Ajitem Sahasrabuddhe Date: Tue Sep 10 15:04:12 2019 +0530 Merge branch 'master' into remove-flag-generation commit 249cb3339254361b1a884733a98d4202e2838b9b Merge: bfe2e92 abfb13b Author: Audrius Butkevicius Date: Tue Sep 10 08:28:09 2019 +0100 Merge pull request #885 from urfave/go-modules-support Go modules support commit abfb13b8542fbe3d542d46543ab0d3be6aacb4e5 Merge: 534d60b bfe2e92 Author: Ajitem Sahasrabuddhe Date: Tue Sep 10 06:56:41 2019 +0530 Merge branch 'master' into go-modules-support commit 054fbefec36cad7425dc6f4cfb6d2963c2710751 Author: Ajitem Sahasrabuddhe Date: Tue Sep 10 06:42:34 2019 +0530 Update CHANGELOG.md commit 534d60bb9bb0476141540ec77c5a3d51e176d162 Author: Ajitem Sahasrabuddhe Date: Tue Sep 10 06:40:45 2019 +0530 Bump minimum supported version of Go to 1.11 commit 024692c172f7000fe2431c3280a1e4b724b15945 Merge: 4a9e440 bfe2e92 Author: Ajitem Sahasrabuddhe Date: Tue Sep 10 06:33:21 2019 +0530 Merge branch 'master' into remove-flag-generation commit bfe2e925cfb6d44b40ad3a779165ea7e8aff9212 Merge: 3eca109 238c80f Author: Ajitem Sahasrabuddhe Date: Tue Sep 10 06:24:10 2019 +0530 Merge pull request #882 from urfave/lynncyrin-patch-1 Release 1.22.0 commit 426e21c150d9a33e4d8c13c2a13c5234e85f3a0e Author: Ajitem Sahasrabuddhe Date: Mon Sep 9 13:15:47 2019 +0530 Update .travis.yml Set GOPROXY in Travis environment commit 39bd6176649871817d1966b6b91f042be4b62fe9 Author: Ajitem Sahasrabuddhe Date: Mon Sep 9 08:37:16 2019 +0530 Cleanup after before_script to avoid git diff errors remove windows build commit edbf66c25cf83541faee77d0064fdb5ac35a51b1 Author: Ajitem Sahasrabuddhe Date: Mon Sep 9 08:23:04 2019 +0530 Update gfmrun import command to suite Go Modules pattern Fix test command typo in travis script commit afd0ecbbf2fbda2f9459046228ccc9e8d2693258 Author: Ajitem Sahasrabuddhe Date: Mon Sep 9 08:19:06 2019 +0530 Add support for Go 1.13 Drop support for Go 1.11 Use md2man v2 to avoid dependency issues when building with Go Modules Enabled Update TravisCI build environment images (trusty was deprecated) Add optional Windows build commit 4a9e440503f4113a351322da93f8630df14dfcaa Author: Ajitem Sahasrabuddhe Date: Mon Sep 9 08:12:09 2019 +0530 Fix AppVeyor build commit 5c81af9f10b974cecbec6e20e4976574e86fc78b Author: Ajitem Sahasrabuddhe Date: Mon Sep 9 07:47:18 2019 +0530 Remove generate script from travis flow Remove unused dependencies from travis script commit b6c5d17a835d17e8dd8f2e34c02e96af7f43c9e4 Author: Ajitem Sahasrabuddhe Date: Mon Sep 9 07:44:07 2019 +0530 Remove Flag Generation Remove Legacy Python Scripts commit 238c80f9b5e54a834f25423fd0887f68b9737cbb Author: Lynn Cyrin (they/them) Date: Sat Sep 7 20:44:48 2019 -0700 Update CHANGELOG.md commit 980742b7cc56e8f7b14b4668fb8ddcf89025c9ea Author: Lynn Cyrin (they/them) Date: Sat Sep 7 20:43:56 2019 -0700 typo commit 890d49ca7a15a3fb7f44d33e5cdb499f0e5c2331 Author: Lynn Cyrin (they/them) Date: Sat Sep 7 20:41:44 2019 -0700 Release 1.22.0 - adds the changelog for 1.22.0 - updates the changelog for 1.21.0. some PRs were missed, as was mentioned here https://github.com/urfave/cli/pull/829#issuecomment-517968795 - closes https://github.com/urfave/cli/issues/867 commit 3eca1090a37a65fea5b84bdbd2c61f8104211b74 Merge: 38a6c56 4bbff84 Author: Audrius Butkevicius Date: Fri Aug 30 15:53:55 2019 +0100 Merge pull request #879 from saschagrunert/escape-single-quotes Escape single quotes in fish shell completion commit 4bbff841690954ed86c147147151c0144dcf1765 Author: Sascha Grunert Date: Thu Aug 29 14:45:32 2019 +0200 Escape single quotes in fish shell completion Single quotes can break the generated fish shell completion and should be escaped correctly. Signed-off-by: Sascha Grunert commit 38a6c560b3b8ac6d47e031a44b92e0531824c7e5 Merge: fa6797b 687f721 Author: Audrius Butkevicius Date: Thu Aug 29 20:52:07 2019 +0100 Merge pull request #857 from saschagrunert/takes-file-fish Add `TakesFile` to fish shell completion commit 687f721eaa40859950820b37b9ad1fcd85b7da9f Author: Sascha Grunert Date: Mon Aug 26 10:07:50 2019 +0200 Update function alignment Signed-off-by: Sascha Grunert commit 0c01922a12c501867cad200bc4b36a25f9a073e0 Author: Sascha Grunert Date: Mon Aug 26 08:46:55 2019 +0200 Add type switch Signed-off-by: Sascha Grunert commit 38d0ac629677a7fbf08a52e17fec73894bb31263 Author: Sascha Grunert Date: Sun Aug 25 17:50:18 2019 +0200 Removed GetTakesFile and stick to type assertions Signed-off-by: Sascha Grunert commit a1cf7f44b6cf65c0c10c282c71524cc37442b798 Author: Sascha Grunert Date: Mon Aug 12 09:42:12 2019 +0200 Add `TakesFile` to fish shell completion The new `TakesFile` flag will be now consumed by the fish shell completion generator. Signed-off-by: Sascha Grunert commit fa6797beefc5727035323623aed515e4dfd3ccdf Merge: 2344c98 82eb0d7 Author: Lynn Cyrin (they/them) Date: Sat Aug 24 18:58:52 2019 -0700 Merge pull request #876 from urfave/lynncyrin-patch-1 Bump go version to 1.10 in readme commit 82eb0d70cbcf89de5e71965fc9ededbb41cdbd96 Merge: edd8cb2 2344c98 Author: Audrius Butkevicius Date: Sun Aug 25 01:04:33 2019 +0100 Merge branch 'master' into lynncyrin-patch-1 commit 2344c98f678ac236c6bf952fe724bc5b0a6bd69b Merge: 55de011 68ee2bc Author: Audrius Butkevicius Date: Sun Aug 25 01:04:17 2019 +0100 Merge pull request #860 from saschagrunert/takes-file-not-all Update `TakesFile` flag to apply only to supported flags commit edd8cb2068b6501d6b631299038cb42194926a8e Author: Lynn Cyrin (they/them) Date: Sat Aug 24 14:44:56 2019 -0700 Bump go version to 1.10 in readme Closes https://github.com/urfave/cli/issues/875 commit 68ee2bc4af27ae14cedbfb881384b0900a0ed3a9 Merge: 959d9ec 55de011 Author: Lynn Cyrin (they/them) Date: Sat Aug 24 14:34:15 2019 -0700 Merge branch 'master' into takes-file-not-all commit 55de011cf89b3d78842e3b3e2cf92f9d157fa399 Merge: 392c1de d3edef8 Author: Audrius Butkevicius Date: Sat Aug 24 11:55:28 2019 +0100 Merge pull request #873 from urfave/show-test-failures build: show failures when running tests commit d3edef887a2fc39830216cd41b16955ef60d0d3c Author: Audrius Butkevicius Date: Sat Aug 24 11:34:03 2019 +0100 Update build.go commit c2d1a132082e3b02a219e61eeef49da364d2c315 Author: Lynn Cyrin Date: Sat Aug 24 03:05:45 2019 -0700 Revert "check length" This reverts commit 1095838cca9d596e55cff88bcb35b67cf83bf4e4. commit 959d9ec36b7848004fd2e85f07b810266d65c8d2 Merge: 3681b05 392c1de Author: Sascha Grunert Date: Sat Aug 24 11:23:51 2019 +0200 Merge branch 'master' into takes-file-not-all commit 7d62a9d0547cbab68e78c2c92a79db97ee61f115 Merge: 1095838 392c1de Author: Lynn Cyrin (they/them) Date: Sat Aug 24 00:50:42 2019 -0700 Merge branch 'master' into show-test-failures commit 1095838cca9d596e55cff88bcb35b67cf83bf4e4 Author: Lynn Cyrin Date: Sat Aug 24 00:49:29 2019 -0700 check length commit 29ad6ee6ad7e02dbec3334e8843bb6711c011b55 Author: [[ BOT ]] Lynn Cyrin Date: Fri Aug 23 20:09:08 2019 -0700 DRY commit 392c1de1a2b3f8bc2ca95c2389dd05469d347b14 Merge: 23c8303 487c723 Author: Audrius Butkevicius Date: Fri Aug 23 22:51:39 2019 +0100 Merge pull request #874 from saschagrunert/go-mod-cleanup Cleanup go modules commit 487c7236736db7d5d2e46633d09453d0e149a0bd Author: Sascha Grunert Date: Fri Aug 23 10:28:32 2019 +0200 Cleanup go modules These two dependencies are not really needed, which can be reproduced via: ``` > export GO111MODULE=on && go mod tidy ``` Signed-off-by: Sascha Grunert commit 8469a9de07c45435b61cbfd4aed7167fb9e59cca Author: [[ BOT ]] Lynn Cyrin Date: Thu Aug 22 21:42:07 2019 -0700 show test failures commit 23c83030263f7adfc0e3c34b567ee508e8d536cf Merge: ecd576e 6a25af9 Author: Lynn Cyrin (they/them) Date: Sat Aug 17 11:24:05 2019 -0700 Merge pull request #862 from russoj88/UpdateREADME_gopkg.in_v1 Rewrite the "pinning to v1" section. commit 6a25af96413deaeb4d6c451d6288079db0840a82 Merge: 3bc62c4 ecd576e Author: russoj88 Date: Sat Aug 17 10:01:35 2019 -0700 Merge branch 'master' into UpdateREADME_gopkg.in_v1 commit ecd576e779bce41496738b34e9ee6272c63801d0 Merge: 6cc7e98 e11183f Author: Audrius Butkevicius Date: Sat Aug 17 16:51:43 2019 +0100 Merge pull request #868 from urfave/lynncyrin-patch-1 Modernize readme commit e11183fe50e3b3d75e481b1262e3222c565ba8bf Author: Lynn Cyrin (they/them) Date: Sat Aug 17 02:44:49 2019 -0700 Modernize readme I assume that people no longer care about what the package was named many years ago commit 3bc62c4fde03e107cad02f8828780470258b8fc0 Author: russoj88 Date: Thu Aug 15 12:30:29 2019 -0700 Mimic v2 example code from above. commit 62b8a7cc2cb05b1a454908087b35e5780a1d12ad Author: russoj88 Date: Wed Aug 14 11:20:09 2019 -0700 Add "Using v1 releases" to table of contents. commit cc091db561b137c49cbf370766a94b47cfdae182 Author: russoj88 Date: Wed Aug 14 11:21:40 2019 -0700 Update README.md Only instruct on right way to use library. Co-Authored-By: Lynn Cyrin (they/them) commit f529dad70caa6e307f95eecb2db6f16efc0f964d Author: russoj88 Date: Wed Aug 14 11:20:58 2019 -0700 Update README.md Include suggestion to put example in. Co-Authored-By: Lynn Cyrin (they/them) commit f2c26bab772e6b69a9fca945534728678578eb2b Author: russoj88 Date: Tue Aug 13 21:10:38 2019 -0700 Rewrite the "pinning to v1" section. commit 3681b057c5df7f380e75974674a8282cf5632dc3 Author: Sascha Grunert Date: Tue Aug 13 09:43:57 2019 +0200 Update `TakesFile` flag to apply only to supported flags Signed-off-by: Sascha Grunert commit 6cc7e987c4fa553caa5014c7dbc1e7acaea9f0f1 Merge: 7e49cc2 08c24e2 Author: Audrius Butkevicius Date: Mon Aug 12 21:30:37 2019 +0100 Merge pull request #856 from FaranIdo/master Add Subcommand fallback call to ExitErrHandler, fixing #816 commit 08c24e22ed2c4bebb348a738caf92c40bb63133c Author: FaranIdo Date: Mon Aug 12 00:29:46 2019 +0300 add missing ExitErrHandler in command + matching test, fixing #816 commit 7e49cc210a231eec218c2fba82df106af06d05b5 Merge: 8b18c71 4e42a2f Author: Ajitem Sahasrabuddhe Date: Sat Aug 10 09:01:16 2019 +0000 Merge pull request #848 from saschagrunert/fish-shell Add fish shell completion support commit 4e42a2f02ceb3cbfe2f8c4e5c6e419a712c335c9 Merge: 56d12d0 8b18c71 Author: Ajitem Sahasrabuddhe Date: Sat Aug 10 08:47:31 2019 +0000 Merge branch 'master' into fish-shell commit 8b18c71e1a4eabe8d7ba20d81d7fbd882709833d Merge: 7058c58 c6c2008 Author: Ajitem Sahasrabuddhe Date: Sat Aug 10 08:47:23 2019 +0000 Merge pull request #851 from saschagrunert/takes-file Add `TakesFile` indicator to flag commit 56d12d0c2f27a159e95165cf3cec2396df6f68af Merge: 7506b11 7058c58 Author: Ajitem Sahasrabuddhe Date: Fri Aug 9 17:21:24 2019 +0530 Merge branch 'master' into fish-shell commit c6c200864d770982106717a20ad99603396fb042 Merge: e9e9e0a 7058c58 Author: Sascha Grunert Date: Fri Aug 9 13:48:36 2019 +0200 Merge branch 'master' into takes-file commit 7058c58eb6af9ee166dafdf82012e1241890223d Merge: 2e0e39a de0fa70 Author: Ajitem Sahasrabuddhe Date: Fri Aug 9 17:16:13 2019 +0530 Merge pull request #847 from saschagrunert/remove-date-var Remove unused `Date` variable from `cliTemplate` commit de0fa704331adf0183d6f1b6d94a2390a48a810c Merge: 0d79d1d 2e0e39a Author: Audrius Butkevicius Date: Fri Aug 9 12:38:50 2019 +0100 Merge branch 'master' into remove-date-var commit e9e9e0ac5dfce215fb2207b3bbde2534a67907f6 Author: Sascha Grunert Date: Fri Aug 9 09:05:55 2019 +0200 Add `TakesFile` indicator to flag This new member of `Flag` indicates if the flag expects a file as input. This is especially useful for documentation and shell completion purposes. Signed-off-by: Sascha Grunert commit 7506b11da746beef287831f805f5b0e49264b400 Author: Sascha Grunert Date: Thu Aug 8 15:50:36 2019 +0200 Add fish shell completion support This commit adds a new method `ToFishCompletion` to the `*App` which can be used to generate a fish completion string for the application. Relates to: #351 Signed-off-by: Sascha Grunert commit 2e0e39a03b46023f83ec2e70f1948836e0581543 Merge: 946f918 aed704a Author: Ajitem Sahasrabuddhe Date: Fri Aug 9 10:34:28 2019 +0530 Merge pull request #845 from urfave/lint-fixes linter fixes commit 0d79d1d9d99db9e380e37034f677523b0ca435b5 Author: Sascha Grunert Date: Thu Aug 8 14:04:21 2019 +0200 Remove unused `Date` variable from `cliTemplate` Signed-off-by: Sascha Grunert commit aed704a9d036852c332867dffd97c60c51e8a38d Merge: 0990ca2 946f918 Author: Ajitem Sahasrabuddhe Date: Thu Aug 8 14:44:02 2019 +0530 Merge branch 'master' into lint-fixes commit 946f918365f62f6fe8d7fb7d4ea54dd441eccfb6 Merge: 2c477e7 286133f Author: Audrius Butkevicius Date: Thu Aug 8 09:13:09 2019 +0100 Merge pull request #735 from rliebz/combined Add app-wide support for combining short flags commit 0990ca2391ac8a72bc59d393e64ca520d9c53772 Merge: fdba7e0 2c477e7 Author: Ajitem Sahasrabuddhe Date: Thu Aug 8 13:36:30 2019 +0530 Merge branch 'master' into lint-fixes commit 286133fee5ef662bcfc9fdb7e410ce83528ab1f8 Merge: 815c29f 2c477e7 Author: Ajitem Sahasrabuddhe Date: Thu Aug 8 13:33:32 2019 +0530 Merge branch 'master' into combined commit 2c477e720e69b9ce81e9d6cf68c81a0334446016 Merge: e0057bb 99fad61 Author: Audrius Butkevicius Date: Thu Aug 8 08:41:19 2019 +0100 Merge pull request #830 from saschagrunert/docs-gen Add markdown and man page docs generation methods commit 99fad61ded52131321a0d7e5d330554512254ebe Merge: 40d4a25 e0057bb Author: Audrius Butkevicius Date: Thu Aug 8 07:06:08 2019 +0100 Merge branch 'master' into docs-gen commit e0057bb59731900e8b702b0b5282378577cb99e5 Merge: 521735b fd39578 Author: Audrius Butkevicius Date: Thu Aug 8 07:04:25 2019 +0100 Merge pull request #846 from urfave/asahasrabuddhe-patch-1 Update README.md commit 815c29ffc73623b32e587298eeda0a0dd2ff5737 Merge: a77c440 521735b Author: Audrius Butkevicius Date: Thu Aug 8 07:03:49 2019 +0100 Merge branch 'master' into combined commit fd395786a2c77da3f111c6208ba50b3041fe6ee2 Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 21:00:07 2019 +0530 Update README.md remove quotes around coverage badge commit fdba7e0f8c921d4ce169cb416b2eae58026c83e9 Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 20:14:50 2019 +0530 linter fixes code cleanup changing some test code to ensure uniformity commit 40d4a25a01296d2f51bf7bbf0b6e8eb99ba4a84c Author: Sascha Grunert Date: Sat Aug 3 12:41:50 2019 +0200 Add markdown and man page docs generation methods This adds two new methods to the `App` struct: - `ToMarkdown`: creates a markdown documentation string - `ToMan`: creates a man page string Signed-off-by: Sascha Grunert commit 521735b7608a25d771a39d42e2267e061e7e84b8 Merge: 97179ca 22e1fc8 Author: Audrius Butkevicius Date: Wed Aug 7 12:10:34 2019 +0100 Merge pull request #844 from urfave/asahasrabuddhe-patch-1 Update README.md commit 22e1fc84192059f056a7b53aa5ef2ee7113d9a83 Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 14:02:52 2019 +0530 Update README.md add codecov.io badge commit 97179ca390abf228a187e6ebbedca69636d60f0d Merge: b6f7dd9 3a41d6d Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 13:58:51 2019 +0530 Merge pull request #843 from lafriks/patch-1 Support GoLang 1.10 to 1.12 commit 3a41d6d7851b15f132131444865e82b17baf0be0 Author: Lauris BH Date: Wed Aug 7 11:21:31 2019 +0300 Lower support to GoLang compiler version 1.10 commit 1f4473209dcad42ed88ba68f1be7d4e906ae91be Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 13:50:04 2019 +0530 Update .travis.yml support go versions in line with go's release policy commit e3fa7e8566f9374ac6c1e08ace0e0555f9666e10 Author: Lauris BH Date: Wed Aug 7 11:06:15 2019 +0300 Support also GoLang 1.11 compiler commit b6f7dd93594d17c08d349ba5f974e501b8c12b7b Merge: 93392d1 e2de8c7 Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 13:28:34 2019 +0530 Merge pull request #836 from urfave/flag-type-generation-golang Flag Generation in the CLI commit e2de8c74587d464770155415cda09c3569224692 Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 12:38:17 2019 +0530 update readme with correct error message, add 1.12 and 1.11 to travis commit a77c440b8476d59b59fcf2606a92fd3bb82603c3 Merge: 8d31c5e 93392d1 Author: Robert Liebowitz Date: Tue Aug 6 22:33:49 2019 -0400 Merge branch 'master' into combined commit 24de27b05e91ef797b9ba97e3c146842fb8e29d8 Merge: c19938f 93392d1 Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 01:54:44 2019 +0530 Merge branch 'master' into flag-type-generation-golang commit c19938fbbfb19120beeca5d0af02291a99e61f27 Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 01:51:02 2019 +0530 update ci commands commit 6ee5b89e03a0fc47c6351c902ef714f1475e8fde Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 01:50:50 2019 +0530 move build.go to root commit e8bbb4c3b5472320f0af5fb00961c76f1061edd4 Author: Ajitem Sahasrabuddhe Date: Wed Aug 7 01:46:22 2019 +0530 remove unnecessary sprintf commit 5070d00811cd5f2f21b0a6e021581e8efb2479e9 Author: Ajitem Sahasrabuddhe Date: Tue Aug 6 12:33:33 2019 +0530 move packages slice to global scope commit 93392d12e8cd60a1c7c62dc4bf4bab7a8e001eec Merge: 26945c5 1db0496 Author: Audrius Butkevicius Date: Tue Aug 6 07:59:53 2019 +0100 Merge pull request #808 from yogeshlonkar/master Add support for flags bash completion commit adfe6a09c121a6b96357ea161f2d679d509c013f Author: Ajitem Sahasrabuddhe Date: Tue Aug 6 12:14:18 2019 +0530 indenting fix commit 1db049685ac49e11b2e27285e1287793cfe0ea84 Author: Yogesh Lonkar Date: Mon Aug 5 20:22:52 2019 +0200 Fix unused regex commit 2be2bc755e4634d34136769a426a7ca52e698cc0 Author: Yogesh Lonkar Date: Mon Aug 5 20:18:08 2019 +0200 Add additional test for log flag completion and comments commit c3f51bed6fffdf84227c5b59bd3f2e90683314df Author: Yogesh Lonkar Date: Mon Aug 5 17:07:46 2019 +0200 Fix SC2199: Arrays implicitly concatenate in commit c5612e8cd21e0cd99f73d23103df99a9af70f853 Author: Yogesh Lonkar Date: Mon Aug 5 16:58:04 2019 +0200 Fix review comments commit 8d31c5e167103ef4235cc5553b0fb45a2f6e8f74 Author: Robert Liebowitz Date: Mon Aug 5 07:05:07 2019 -0400 Update README.md Co-Authored-By: Ajitem Sahasrabuddhe commit 03153b9cf8988d787fe79d02bd4138283ea507bd Author: Robert Liebowitz Date: Mon Aug 5 06:16:30 2019 -0400 Allow combining short flags globally commit d6523cf8692d40c0ff9f6d81f7ac25341c58da7a Merge: e949dc2 26945c5 Author: Yogesh Lonkar Date: Mon Aug 5 11:00:26 2019 +0200 Merge branch 'master' into master commit 26945c58edddd8cb0830baf73ebc7bee44b5f455 Merge: d09efb5 c25e4ca Author: Lynn Cyrin (they/them) Date: Sun Aug 4 12:36:23 2019 -0700 Merge pull request #823 from xordspar0/master Make the exit code example more clear commit c25e4cab32bab49d1d3c4847a0a6419e2cb3dd15 Merge: b1a7c50 d09efb5 Author: Lynn Cyrin (they/them) Date: Sun Aug 4 12:30:28 2019 -0700 Merge branch 'master' into master commit ac5c97b41844032ae47d5f94d7f73533af629f11 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 20:45:28 2019 +0530 add latest assets file commit 489d92d2e2477b240015e83af07658e826eaa7cb Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 20:44:15 2019 +0530 add missing os package commit a7f0d86509d0845980b77999dc5882b32f244818 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 20:33:21 2019 +0530 add zero mod fs back and commit file with latest ts commit 798e1f3d3aba8d04c9118962870b41ad099b7bea Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 20:29:53 2019 +0530 fix spacing issue commit 7a6f3d4394003447c99b223ce1c1e19e23b20124 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 20:23:32 2019 +0530 fix tests commit 58ae5eb590667b0115d3f82e03593d87e2924b1c Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 20:06:44 2019 +0530 move entire build system to go commit 8547458f1d93654348b3bbeccb6d04424d5eab3e Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 19:01:47 2019 +0530 remove zero mod fs commit d09efb5fbd744f23d561c02b99a16a61e679bba6 Merge: 7745000 1327f58 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 18:00:11 2019 +0530 Merge pull request #837 from urfave/codeowners Use codeowners instead of maintainers commit 1327f583142a70a5d2fb9ef8422862b84a1a8780 Merge: 9938dec 7745000 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 17:52:42 2019 +0530 Merge branch 'master' into codeowners commit e949dc2cc05a553645eea447ded78eddfec0ad37 Merge: 11c9e59 7745000 Author: Yogesh Lonkar Date: Sun Aug 4 10:38:56 2019 +0200 Merge branch 'master' into master commit 4b0a4104630bddd01a7a6c5aa8a70dc94642ab52 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 12:26:48 2019 +0530 fix travis build commit fb4cea5f30995b6caaa700ea789902af499d63b2 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 12:22:45 2019 +0530 add new generation logic to travis commit 365557021fe254d059d0f7065bb0c94686208723 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 12:17:27 2019 +0530 remove legacy version check code commit b6bfbe97f8430a4dfe05791363719d61cb921793 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 12:16:07 2019 +0530 update appveyor to go 1.11, add support for code coverage generation in tests commit 826954c97919610e0f4086ab3bcc007ac3326184 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 11:09:34 2019 +0530 update app name and remove version commit 04948f21526ed8343ae9697600e284962d8972be Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 11:06:19 2019 +0530 generate test with go generate commit 86e10211dea0c2b369610aabea1c987888bbb01a Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 11:05:50 2019 +0530 remove redundant go generate from altsrc update go generate in cli package to generate both files regeneration test commit c676ed4caa76219414ad737584ec46b03e94cbf8 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 11:04:23 2019 +0530 indentation fixes in template regeneration test commit c4fc88e46d182072228b2b2a0236b0f77a45e567 Merge: 2a08494 9260850 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 10:29:34 2019 +0530 Merge branch 'flag-type-generation-golang' of https://github.com/urfave/cli into flag-type-generation-golang commit 2a084945a47235959c023291f87127ead86fc168 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 10:28:08 2019 +0530 move around code change package to flag-gen to avoid conflict with flag-generator binary test code generation commit 065fe9e9af992d82126929c157edb16b1a1f06ab Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 10:05:44 2019 +0530 change structure to embed source json and template files restructure code to have defaults in place of choices commit d1ded77768d33ce64657686558884e69cbb5bce4 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 08:45:29 2019 +0530 rename utility from fg > flag-generator commit 7745000a0eabd118a94df095da6feeae887f9a34 Merge: e6cf83e 81acbeb Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 08:15:00 2019 +0530 Merge pull request #774 from whereswaldon/patch-1 Clarify that altsrc supports both TOML and JSON commit 81acbeb629cebde2c8c3c36421644e42ffd9e8f9 Merge: 8abc5a2 e6cf83e Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 08:12:24 2019 +0530 Merge branch 'master' into patch-1 commit e6cf83ec39f6e1158ced1927d4ed14578fda8edb Merge: 244eba7 eee6ce8 Author: Lynn Cyrin (they/them) Date: Sat Aug 3 19:37:52 2019 -0700 Merge pull request #829 from urfave/lynncyrin-patch-2 Release 1.21.0 commit 8abc5a2e49624c8f12a0b1734b57bd12aadf1604 Merge: b2421d1 244eba7 Author: Ajitem Sahasrabuddhe Date: Sun Aug 4 08:04:13 2019 +0530 Merge branch 'master' into patch-1 commit 9938dec695d6a0ba5a4d84b703766333cd7d10e8 Author: [[ BOT ]] Lynn Cyrin Date: Sat Aug 3 10:26:07 2019 -0700 update contributing docs commit 97dbddb32db290fdc6392e6a669a92acbadef9ff Author: [[ BOT ]] Lynn Cyrin Date: Sat Aug 3 10:23:29 2019 -0700 use codeowners instead of maintainers commit 92608509a4c011a598dcc5b10d15930040fa403e Merge: d209be3 244eba7 Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 22:49:24 2019 +0530 Merge branch 'master' into flag-type-generation-golang commit d209be324522a802f8056094f8bb89b4562ca9a3 Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 22:32:36 2019 +0530 update go generate command test file generation commit add69c7d4fbef52ac8541c2f7dfa465fdd9be2c3 Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 22:16:25 2019 +0530 updated flag types generated courtesy fg cli commit c133a5aeb16e0978e3c29f8446ddf02922b7e150 Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 22:15:43 2019 +0530 add explicit true/false choices for value and dest keys due to go default false for bool types commit 16c7a60528bc5f7d98030e09630a38f3d8fc9ddc Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 22:14:58 2019 +0530 finish generation of flag types for altsrc package rename package to fg (flag generator) commit 32ddef5ca7f20a9aa0e7b80484e59d1653e856e4 Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 21:48:48 2019 +0530 finish generation of flag types for cli package commit 9766be8d3e11e71a2a4bb5c235fc6961278df983 Author: mingrammer Date: Thu Mar 7 00:04:18 2019 +0900 get latest changes from master commit e01e3c540c7aea9e4e9740d002bd212491c2fe00 Author: mingrammer Date: Wed Mar 6 23:51:22 2019 +0900 Fix the unaligned indents for the commands that have no categories commit b1a7c502eba6a479bf9432052136f73d7740a69b Merge: c75a689 244eba7 Author: Lynn Cyrin (they/them) Date: Sat Aug 3 09:36:27 2019 -0700 Merge branch 'master' into master commit eee6ce83c075e8aeb1d71a22f69e6fddbc70a248 Merge: 8a7f65e 244eba7 Author: Lynn Cyrin (they/them) Date: Sat Aug 3 09:06:47 2019 -0700 Merge branch 'master' into lynncyrin-patch-2 commit 11c9e598b06a0a2201f356f945c4cd2355a8ccbf Merge: 01ab016 244eba7 Author: Yogesh Lonkar Date: Sat Aug 3 15:52:08 2019 +0200 Merge branch 'master' into master commit 244eba7e4c24eb9a416bb1edadaf74d943a7bb89 Merge: 1169906 4627bbe Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 18:04:31 2019 +0530 Merge pull request #831 from saschagrunert/go-modules Add go module support commit b2421d123539be62bc9f2f9bdd77fce3cc2d1af6 Merge: 3e14507 1169906 Author: Audrius Butkevicius Date: Sat Aug 3 13:25:34 2019 +0100 Merge branch 'master' into patch-1 commit 4627bbe109fb902221de0a86f20048ad5679ea0c Author: Sascha Grunert Date: Sat Aug 3 12:55:06 2019 +0200 Add go module support This adds a go.{mod,sum} file to official support go modules. Signed-off-by: Sascha Grunert commit 1169906f575ec070559cc1a6fc083b38498160c0 Merge: 07c1638 94f4f83 Author: Audrius Butkevicius Date: Sat Aug 3 11:02:34 2019 +0100 Merge pull request #773 from teresy/redundant-nil-check-slice Remove redundant nil checks commit 94f4f8367278436d4554b3e7a72ec6b66c209312 Merge: da581b2 07c1638 Author: Lynn Cyrin (they/them) Date: Sat Aug 3 02:05:33 2019 -0700 Merge branch 'master' into redundant-nil-check-slice commit 07c163896936a0fb3ad24dcbf05b25e9c7aaee53 Merge: 842e3fe 7a51175 Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 08:47:32 2019 +0530 Merge pull request #806 from mingrammer/fix-help-indentation Fix the unaligned indents for the command help messages commit 7a51175ce1cb78d5009e91001697240c1af84ee2 Merge: 330a914 842e3fe Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 08:37:34 2019 +0530 Merge branch 'master' into fix-help-indentation commit 842e3fe1b6adbb257f711a1f66553ad03174c5c0 Merge: 7675649 fa51d00 Author: Ajitem Sahasrabuddhe Date: Sat Aug 3 08:12:05 2019 +0530 Merge pull request #828 from urfave/lynncyrin-patch-1 Update maintainers for current reality commit 8a7f65e05215a76a2246b7b42cb9c082b5eae483 Author: Lynn Cyrin (they/them) Date: Fri Aug 2 19:30:41 2019 -0700 Update CHANGELOG.md commit e8eac43d9d73e96f6b034f89770ab2fdbec2cb5b Author: Lynn Cyrin Date: Fri Aug 2 18:26:41 2019 -0700 Update CHANGELOG.md commit 330a9143fb1ebfe61bb382b5e45833c02a405c0c Merge: ddc3453 7675649 Author: Lynn Cyrin Date: Fri Aug 2 18:14:50 2019 -0700 Merge branch 'master' into fix-help-indentation commit fa51d00dc6fb57edca14295fde308401d7720e61 Author: Lynn Cyrin Date: Fri Aug 2 18:06:15 2019 -0700 Update maintainers for current reality commit 01ab0164275805b0c43bc5f7f534a2d8f6abe48e Merge: d79d2a0 7675649 Author: Yogesh Lonkar Date: Fri Aug 2 22:03:55 2019 +0200 Merge branch 'master' into master commit c75a689f629137700e8a30651f95cc41cf12a6d1 Author: Jordan Christiansen Date: Fri Aug 2 14:28:57 2019 -0500 Make exit code example more clear The purpose of this example is to show that you can exit with an error code if a flag is unspecified, but with the code as it is, the only way to cause a non-zero exit is by adding the flag `--ginger-crouton=false`, which is not explained in the example. In this new version of the example, running the command with no flag will exit with an error, and running it with the flag will exit normally. commit 7675649a174ac724b1d7fa9d5932eff3dd1582a2 Merge: 656063a f8ba505 Author: Ajitem Sahasrabuddhe Date: Fri Aug 2 22:52:32 2019 +0530 Merge pull request #819 from lynncyrin/required-flags-take-2 Required flags commit f8ba505a7cc01559767d9d961fb68bda833d5d3d Merge: 60fb297 656063a Author: Ajitem Sahasrabuddhe Date: Fri Aug 2 22:49:29 2019 +0530 Merge branch 'master' into required-flags-take-2 commit 656063a84689d3e45f16ab9c40706e4df219190a Merge: 693af58 6505336 Author: Ajitem Sahasrabuddhe Date: Fri Aug 2 22:49:09 2019 +0530 Merge pull request #788 from benzvan/master adds test coverage to context commit 60fb2972328d6a7487c6821a58a86d476167c2bd Author: Lynn Cyrin Date: Thu Aug 1 23:27:34 2019 -0700 remove help assertion stuff commit d7ec4e801357fa5ccfab53669a42f78fc1a69d39 Author: Lynn Cyrin Date: Thu Aug 1 23:26:43 2019 -0700 add env var tests commit f4128a02f3215e532dff0b96e21a8e2cb08389a1 Author: Lynn Cyrin Date: Thu Aug 1 22:54:15 2019 -0700 Update command.go commit 38f9e1622d2d4a5e1a86afd8f8f9d6cbf0157816 Author: Lynn Cyrin Date: Thu Aug 1 22:52:21 2019 -0700 add environment variable support :tada: commit f21b22dd904b638518d9ea321d718f219bd6593c Author: Lynn Cyrin Date: Thu Aug 1 22:10:18 2019 -0700 cleanup some issues with error display commit fdd4d106912b363ccffa03eec51a56dd3a6a822b Author: Lynn Cyrin Date: Thu Aug 1 21:48:52 2019 -0700 update comments commit ef9acb4a3b846728c98844f7f92964ae2a79f259 Author: Lynn Cyrin Date: Thu Aug 1 21:46:56 2019 -0700 rename cases commit 45f2b3d8e71e11822cf591f1c370f8587726c425 Author: Lynn Cyrin Date: Thu Aug 1 21:45:11 2019 -0700 more test cases commit 78db152323afb7934f9f0dd207eeaf34147bb300 Author: Lynn Cyrin Date: Thu Aug 1 21:35:15 2019 -0700 add typed error assertions commit d4740d10d0cbde53a8e3132a0964464b2b50fc0b Author: Lynn Cyrin Date: Thu Aug 1 20:58:08 2019 -0700 more test cases commit 595382c50970039261f765043aee4c647aeccbd5 Author: Lynn Cyrin Date: Thu Aug 1 20:39:37 2019 -0700 expand test cases commit 3d6eec825ac768894a385ca3c3156a7905c27ce3 Author: Lynn Cyrin Date: Thu Aug 1 20:35:23 2019 -0700 add test cases commit 7b9e16b6b5255803ea279fe1ee0e41973f49a42e Author: Lynn Cyrin Date: Thu Aug 1 20:30:43 2019 -0700 update test names commit 95d3a8624d8aa6661831d0009550b602458fcb4d Author: Lynn Cyrin Date: Thu Aug 1 20:27:51 2019 -0700 update test to reflect app flag usage commit 714a73f028fa5a3c5b6512bf5e55b94be388de8f Author: Lynn Cyrin Date: Thu Aug 1 19:57:14 2019 -0700 remove unused thing commit 9438aba3b89e7053070ef277121a14e5fb95947e Author: Lynn Cyrin Date: Thu Aug 1 19:54:57 2019 -0700 remove showFlagError, we can use the help printer assertion to accomplish the same goal commit 386b379d1950e8939c8a3dbba0335cf79903f421 Author: Lynn Cyrin Date: Sun Jul 28 22:45:43 2019 -0700 Revert "reset generated flags changes" This reverts commit 9ec594d5290b846de59b0bc350849b848cabfbd7. commit 9ec594d5290b846de59b0bc350849b848cabfbd7 Author: Lynn Cyrin Date: Sun Jul 28 22:34:07 2019 -0700 reset generated flags changes commit 23f09ac1e82395dc1a70c36d649ab03929e32d79 Author: Lynn Cyrin Date: Sun Jul 28 22:19:35 2019 -0700 cleanup tests, check required flags in more places commit d79d2a04242b21441061e00475287f4b826614f8 Author: Yogesh Lonkar Date: Wed Jul 24 16:08:47 2019 +0200 Fix issue with source command completion Avoid competion for bash builtin `source` and fallback to default implementation as it throws below error ``` -bash: source: --: invalid option source: usage: source filename [arguments] ``` commit 7ce0af189ed431005f47e583a63648ea9a0a99ea Author: Lynn Cyrin Date: Thu Jul 18 00:52:24 2019 -0700 remove unused code commit d8985dc6d56ac75b35f0422d8efbc04814bf17f3 Author: Lynn Cyrin Date: Thu Jul 18 00:51:16 2019 -0700 reduce diff commit 19140e1fb52f458727a3c718f82fb93861d5849c Author: Lynn Cyrin Date: Thu Jul 18 00:48:09 2019 -0700 show errors commit 2299852c3c3512dafac738a10847da3bb3699b62 Author: Lynn Cyrin Date: Thu Jul 18 00:47:18 2019 -0700 cleanup subcommand and specs commit 300288670fe7713da8ae6e4a449d12e6c911b713 Author: Lynn Cyrin Date: Thu Jul 18 00:20:32 2019 -0700 add subcommand commit cc1cf8c459c947156bb429ef319f4cf762b1e468 Author: Lynn Cyrin Date: Thu Jul 18 00:09:07 2019 -0700 wording shift commit 32d84d8e870a7f475c228c3c58f2c879f6a4009e Author: Lynn Cyrin Date: Wed Jul 17 00:25:13 2019 -0700 copy update commit 01d5cfab7066912c97eeaf94cbbda8f90fc490f7 Author: Lynn Cyrin Date: Wed Jul 17 00:20:44 2019 -0700 use strings.Join commit cdc7af744e07ac8dbb34793f8b392af46ba443f7 Author: Lynn Cyrin Date: Wed Jul 17 00:16:40 2019 -0700 add handling for multiple required flags commit 9293f5b3cc6f5a96a1976bf2f810c957044c5ee8 Author: Lynn Cyrin Date: Sun Jul 14 21:00:16 2019 -0700 visually shorten logic commit f00f35ce8c1a6ebd7a3900901dd8b05049fbefc7 Author: Lynn Cyrin Date: Sat Jul 13 14:02:45 2019 -0700 docs commit 17108e1db49db34480170f575131e642b22bda2d Author: Lynn Cyrin Date: Sat Jul 13 13:59:29 2019 -0700 tabs commit cf824804c2353572e0f99b098829f2d7ffe2a0ec Author: Lynn Cyrin Date: Sat Jul 13 13:57:06 2019 -0700 update tests commit 80d7e91191cfb38c7e3fccbcf2b1320807d4b05d Author: Lynn Cyrin Date: Sat Jul 13 03:51:26 2019 -0700 fill out test cases commit 746866c10daf9425d41140f78ffc518ee4d9ae01 Author: Lynn Cyrin Date: Sat Jul 13 03:44:39 2019 -0700 add update integration with the help output commit 550ed20ea429e19b7b132984a6e34c057acabc42 Author: Lynn Cyrin Date: Sat Jul 13 01:26:47 2019 -0700 update tests commit f6777bf4bf44867abbcaa63a97a67db60469ea80 Author: Lynn Cyrin Date: Sat Jul 13 01:03:46 2019 -0700 quote the flag name commit 6a2ae783730e54eb7ea91cf6839ed46446134017 Author: Lynn Cyrin Date: Thu Jul 11 21:53:10 2019 -0700 backwards compatible RequiredFlag implementation commit 922d2318916c3b59eafde03c36b12551a71f2d51 Author: Lynn Cyrin Date: Thu Jul 11 21:28:09 2019 -0700 ./generate-flag-types cli -i flag-types.json -o flag_generated.go commit 8a58b7e039e37b0631d6ced0ab3279c319c4d8c8 Author: Lynn Cyrin Date: Thu Jul 11 20:47:47 2019 -0700 remove manual isRequired funcs commit 62e99ad1c16714cda6c9f8b980dd9483372771e2 Author: Lynn Cyrin Date: Thu Jul 11 20:46:22 2019 -0700 add IsRequired to generator commit 310bfeb1942571dfe0ac9f60f45e75df11189e4e Author: Lynn Cyrin Date: Thu Jul 11 20:44:41 2019 -0700 add required attr to generator commit af627c73c3ddc2d4ff1e4c0847c3355bc0a47c0d Author: Lynn Cyrin Date: Thu Jul 11 20:34:17 2019 -0700 update func name commit 3d2d6975b4fffee753c9422f3440d6b7c114ef40 Author: Lynn Cyrin Date: Thu Jul 11 20:32:42 2019 -0700 reduce diff commit 0608059cc709e86905bfd18886d6649275c9937e Author: Lynn Cyrin Date: Thu Jul 11 20:32:15 2019 -0700 reduce diff commit 9c299e7e8af265e017adf7abf431a0fe0c89dd95 Author: Lynn Cyrin Date: Thu Jul 11 20:28:29 2019 -0700 reduce diff commit 30a71dc427bc2634f00d9fe315e5717022e0eb66 Author: Lynn Cyrin Date: Thu Jul 11 20:25:52 2019 -0700 update Run command commit f7d5e2c21e4cca02de26a7f448d69f4dac531af7 Author: Lynn Cyrin Date: Thu Jul 11 20:22:16 2019 -0700 reduce diff commit e6842c0b7521b5e608da30a4e8a5ed06e6469cf7 Author: Lynn Cyrin Date: Thu Jul 11 20:21:05 2019 -0700 merge in test file commit fa8187f2ce6a7d8258899b46ccfe081c9c0ea6f7 Author: Lynn Cyrin Date: Thu Jul 11 20:19:42 2019 -0700 reduce diff commit ce1630141e70b2ca599a21fd9494e98b88f25b2d Author: Lynn Cyrin Date: Thu Jul 11 20:18:52 2019 -0700 reduce diff??? commit 138dbaafec9db29d5b0b10af383ca7c6848a2c0d Merge: aba73ce 693af58 Author: Lynn Cyrin Date: Thu Jul 11 20:07:55 2019 -0700 Merge branch 'master' into required_flags commit da581b24e88a3b8d5b3d4b7685f9eee32ec0df8e Merge: 6aa7f35 693af58 Author: Audrius Butkevicius Date: Fri Jun 28 07:55:04 2019 +0100 Merge branch 'master' into redundant-nil-check-slice commit 65053360c7533fc585bdb9f53abada1e9b39f564 Author: Ben Zvan Date: Wed Jun 26 09:41:11 2019 -0500 Revert "Created using Colaboratory" This reverts commit 83b99c4109dce6ac7a6b5d2048e26f1ad60ef3f3. This commit was randomly created here when I connected to colaboratory commit 83b99c4109dce6ac7a6b5d2048e26f1ad60ef3f3 Author: Ben Zvan Date: Tue Jun 25 18:47:58 2019 -0500 Created using Colaboratory commit 23042d37079702af32e4bcae8d41bb72569431da Merge: 4a76377 693af58 Author: Ben Zvan Date: Fri Jun 14 10:14:07 2019 -0500 Merge branch 'master' into master commit 62f02f21ef0b5c3c0aa67d3240aee15bc8a53457 Author: Yogesh Lonkar Date: Thu Apr 11 10:57:58 2019 +0530 Don't complete hidden flags commit 1d7a2b08d6f8e9764e2f2b911b1bb9fa49596f92 Author: Yogesh Lonkar Date: Thu Mar 21 13:01:48 2019 +0530 Add default completion on commands, test cases, refactor code commit fb1421d9031313c5e0f3c4a92625ed9cf5739b0d Author: Yogesh Lonkar Date: Wed Mar 20 21:34:56 2019 +0530 Fix duplicate completion of existing flag commit 58a072d5733d4bb2dc61ffbc3557ec9592e34adc Author: Yogesh Lonkar Date: Wed Mar 20 20:28:51 2019 +0530 Add bash completion support for flags commit ddc3453179ea450663473db4689f7c256225a72b Author: mingrammer Date: Thu Mar 7 00:04:18 2019 +0900 Update README.md commit a0453b2200cafa97ce263a4a5df87f5087d2abda Author: mingrammer Date: Wed Mar 6 23:51:22 2019 +0900 Fix the unaligned indents for the commands that have no categories commit 693af58b4d51b8fcc7f9d89576da170765980581 Merge: e229212 d7c3be8 Author: Audrius Butkevicius Date: Sun Feb 3 18:40:40 2019 +0000 Merge pull request #766 from agis/patch-1 Fix README typo commit 6aa7f352fa56438b4c8fcaff43e1050855526051 Merge: 21dfc6e e229212 Author: Audrius Butkevicius Date: Sun Feb 3 18:39:49 2019 +0000 Merge branch 'master' into redundant-nil-check-slice commit e2292127695d01e9fc3511f2ec7ef651bf3ca8af Merge: b67dcf9 5b83c89 Author: Audrius Butkevicius Date: Sun Feb 3 18:37:18 2019 +0000 Merge pull request #798 from Quasilyte/patch-1 use type switch instead of if/else commit 5b83c895a70b7714548f0aa4f43deb3fa5fc1601 Author: Iskander (Alex) Sharipov Date: Tue Jan 29 22:51:02 2019 +0300 use type switch instead of if/else This reduces the syntax noise of the code by removing excessive type assertions. Signed-off-by: Iskander Sharipov commit 4a76377775cebfc3dca4af752ba2837f9694b9d8 Author: Ben Zvan Date: Wed Dec 26 12:48:12 2018 -0600 go fmt commit d63733fe14aad10beca5490a453904bc1d67fe16 Author: Ben Zvan Date: Wed Dec 26 12:41:27 2018 -0600 adds test coverage to context commit b67dcf995b6a7b7f14fad5fcb7cc5441b05e814b Merge: cbebba9 11ab68f Author: Audrius Butkevicius Date: Mon Oct 29 21:32:00 2018 +0000 Merge pull request #776 from gliptak/patch-2 Bring Go version current commit 11ab68f24d392fc36615c650bc6241c0b96c4318 Merge: 769f6d5 cbebba9 Author: Audrius Butkevicius Date: Mon Oct 29 21:19:45 2018 +0000 Merge branch 'master' into patch-2 commit cbebba941b23ee6f666b057c9f3d0937263ddd01 Merge: 934abfb 9587fc2 Author: Audrius Butkevicius Date: Mon Oct 29 21:18:40 2018 +0000 Merge pull request #775 from gliptak/patch-1 Correct typo commit 769f6d543bd3c9b36b98e3a46ad646cf63769120 Author: Gábor Lipták Date: Thu Oct 18 21:00:02 2018 -0400 Bring Go version current commit 9587fc27bd923141975eac8c34288bcf8de5cca2 Author: Gábor Lipták Date: Thu Oct 18 20:56:13 2018 -0400 Correct typo commit 3e145076abdbaf5c6e47e311b5e659251604a49b Author: Christopher Waldon Date: Fri Oct 12 11:30:46 2018 -0400 Clarify that altsrc supports both TOML and JSON commit 21dfc6eb8302c4db3547a22b0843c43e36fe058e Author: teresy Date: Wed Oct 10 14:54:48 2018 -0400 Remove redundant nil checks commit d7c3be82673f869fed4ea77a0c5e3f13bd65ba89 Author: Agis Anastasopoulos <827224+agis@users.noreply.github.com> Date: Tue Aug 21 11:19:37 2018 +0300 Fix README typo commit 934abfb2f102315b5794e15ebc7949e4ca253920 Merge: 8e01ec4 3e5a935 Author: Audrius Butkevicius Date: Tue Aug 21 07:40:27 2018 +0100 Merge pull request #758 from vrothberg/fix-short-opts-parsing short opt handling: fix parsing commit 3e5a935ed3cafadcddc6f5ab2fe7ddd2aa0c3cea Author: Valentin Rothberg Date: Tue Aug 21 08:33:42 2018 +0200 fix `go vet` warning command_test.go:342:3 value declared but not used Signed-off-by: Valentin Rothberg commit c23dfba7018a4666892af705d89150a5f1ac8293 Author: Valentin Rothberg Date: Thu Jun 28 16:41:02 2018 +0200 short opt handling: fix parsing Only split a given string (e.g., "-abc") into short options (e.g., "-a", "-b", "-c") if all those are flags. To further avoid mistakenly transform common arguments, catch "flag provided but not defined" errors to iteratively transform short options. Signed-off-by: Valentin Rothberg Fixes: https://github.com/projectatomic/libpod/issues/714 commit 8e01ec4cd3e2d84ab2fe90d8210528ffbb06d8ff Merge: d4bf9ce 8dc47eb Author: Dan Buch Date: Sun Feb 25 22:02:53 2018 -0500 Merge pull request #598 from urfave/backport-json-support Backport JSON InputSource to v1 commit 8dc47eb3cbaea99e0d3e04424f6f3649657a6944 Merge: f551359 d4bf9ce Author: Dan Buch Date: Sun Feb 25 16:09:48 2018 -0500 Merge branch 'master' into backport-json-support commit d4bf9ce8609adfc60775b62676fa3471e7d978e0 Merge: b09aafd e59e474 Author: Dan Buch Date: Sun Feb 25 16:09:04 2018 -0500 Merge pull request #498 from urfave/merging-jereksel-zsh Merging #489 (plus hack) commit e59e4743b884a22e06b1b78a893c68513c0702b7 Merge: 5fc8124 b09aafd Author: Dan Buch Date: Sat Feb 24 22:02:40 2018 -0500 Merge branch 'master' into merging-jereksel-zsh commit b09aafdfe9ad3fa4353b82eaed4e80598878c128 Merge: 446f49e bc77a15 Author: Dan Buch Date: Sat Feb 24 22:02:19 2018 -0500 Merge pull request #681 from urfave/check-run-error-in-readme Update README examples to check for errors commit 5fc8124af17aae44085140a2a7b3141a973dbda0 Merge: 688c5a9 446f49e Author: Dan Buch Date: Sat Feb 24 21:58:26 2018 -0500 Merge branch 'master' into merging-jereksel-zsh commit bc77a15c69f9aadd39b15be9373abc4916c8ad53 Merge: 59e1ddb 446f49e Author: Dan Buch Date: Sat Feb 24 21:54:06 2018 -0500 Merge branch 'master' into check-run-error-in-readme commit 446f49e78f79a164079a99a88446182703331c75 Merge: a1c7408 45289ea Author: Jesse Szwedko Date: Tue Feb 20 21:16:31 2018 -0800 Merge pull request #715 from urfave/maintainers-notice Adjust contribution and maintainer prose per current reality commit 45289ea7a0de564a71532e13b9916961a38abc8e Author: Dan Buch Date: Tue Feb 20 12:40:43 2018 -0500 Adjust contribution and maintainer prose per current reality commit 59e1ddb43ed48e52bf1a0aca8a310d9bca9897d7 Merge: 9838c8b a1c7408 Author: Dan Buch Date: Tue Feb 13 15:27:04 2018 -0500 Merge branch 'master' into check-run-error-in-readme commit a1c7408de3f632d86eee604a3bb755f1ffb68226 Merge: 803d066 3a87b13 Author: Jesse Szwedko Date: Sat Feb 10 18:18:39 2018 -0800 Merge pull request #712 from windler/fix_args_reorder Fix args reordering when bool flags are present commit 3a87b13b01ac8628694f1e1b20bdb452cc0f54d2 Author: Nico Windler Date: Sat Feb 10 13:35:23 2018 +0100 Fix args reordering when bool flags are present commit 803d0665796d3b09d3190067803fc285d1604732 Merge: 75104e9 d7555e1 Author: Jesse Szwedko Date: Fri Feb 2 13:13:18 2018 -0800 Merge pull request #704 from dolmen/replace-unneeded-Sprintf Fix unnecessary uses of Sprintf commit d7555e172994da8d058334aa1fe69533b1685924 Author: Olivier Mengué Date: Fri Jan 26 21:14:34 2018 +0100 Fix unnecessary uses of Sprintf - use strconv directly - use concatenation for "%s%s" commit 75104e932ac2ddb944a6ea19d9f9f26316ff1145 Merge: 39908eb e38e4ae Author: Jesse Szwedko Date: Sat Jan 6 11:10:48 2018 -0800 Merge pull request #697 from urfave/fix-skip-flag-parsing Fix regression of SkipFlagParsing behavior commit e38e4ae2d05acf5b5164c160a67fb7048e1358b0 Author: Jesse Szwedko Date: Fri Dec 29 13:38:18 2017 -0500 Fix regression of SkipFlagParsing behavior Introduced by df562bf1a8626f2d16f91fcbf7230a5bdca3d592 Was mistakenly prepending the command name. commit 39908eb08fee7c10d842622a114a5c133fb0a3c6 Merge: 119bb65 2610681 Author: Jesse Szwedko Date: Tue Dec 12 08:34:29 2017 -0800 Merge pull request #691 from urfave/refactor-686 Refactor flag handling logic commit 2610681040722bb0a9d04c3a784a44d2efb52379 Merge: 0671b16 119bb65 Author: Jesse Szwedko Date: Mon Dec 11 18:51:46 2017 -0800 Merge branch 'master' into refactor-686 commit 0671b166dcacb3dc1215ba65bf986dab194581dc Author: Jesse Szwedko Date: Mon Dec 4 09:23:40 2017 -0800 Add tests for flag reordering commit 119bb6564841921ce6f1401e0f5d75317bdd9f4d Merge: c9eba3f c6eb2a0 Author: Jesse Szwedko Date: Sun Dec 3 13:42:37 2017 -0800 Merge pull request #690 from gliptak/patch-1 Correct go vet for Go tip commit df562bf1a8626f2d16f91fcbf7230a5bdca3d592 Author: Jesse Szwedko Date: Sun Dec 3 13:38:50 2017 -0800 Refactor flag handling logic Refactor logic introduced by #686 commit c9eba3f37a524c4fed60a8f3585ea5f304fd436d Merge: c6af884 ceaac7c Author: Jesse Szwedko Date: Sun Dec 3 12:48:28 2017 -0800 Merge pull request #686 from baude/shortoptionSkipArg Handle ShortOptions and SkipArgReorder commit c6eb2a051026c083d4e33591f8d6e95d5f4189dc Author: Gábor Lipták Date: Thu Nov 30 19:43:12 2017 -0500 Correct go vet for Go tip https://travis-ci.org/cloudflare/logshare/jobs/309796141#L646 commit ceaac7c9152121e6ba0f3b492b3254d61346f92a Author: baude Date: Mon Nov 20 09:32:03 2017 -0600 Handle ShortOptions and SkipArgReorder There was a bug in parsing when both ShortOptions and SkipArgReorder were being used together. Signed-off-by: baude commit c6af8847eb2b7b297d07c3ede98903e95e680ef9 Merge: 7ace96b 37b7abb Author: Jesse Szwedko Date: Mon Nov 27 19:55:04 2017 -0800 Merge pull request #687 from joshuarubin/master Don't clobber slices with EnvVar commit 37b7abb1c491c8c3630a2a98bb02a7051efbcc06 Author: Joshua Rubin Date: Tue Nov 21 15:21:31 2017 -0700 dont clobber slices with envvar Signed-off-by: Joshua Rubin commit 7ace96b43d4bdc46f81d0d1219742b2469874cf6 Merge: 44cb242 fd5382e Author: Jesse Szwedko Date: Wed Nov 15 20:56:12 2017 -0800 Merge pull request #684 from baude/shortOptionHandling Combine bool short names commit fd5382e7a539858cc19d7eed7755f7102bae5da9 Author: baude Date: Mon Nov 13 15:28:23 2017 -0600 Combine bool short names Adds the ability to allow the combination of bool short-name options. For example, cmd foobar -ov This is done through a bool "UseShortOptionHandler" set in the command struct. Built upon PR #621 Signed-off-by: baude commit 9838c8bcaa19fdb33259f6e0f9740d9fd3cbe13c Author: Jesse Szwedko Date: Sat Nov 11 16:23:24 2017 -0800 Update README examples to check for errors To encourage good practices. commit 43c8c02cf5a10196e5a4c458fdbfee90a561e97c Author: zhuchensong Date: Mon Apr 17 00:47:04 2017 +0800 Support POSIX-style short flag combining commit 44cb242eeb4d76cc813fdc69ba5c4b224677e799 Merge: 7f4b273 f971fca Author: Jesse Szwedko Date: Fri Nov 3 19:35:40 2017 -0700 Merge pull request #675 from jmccann/continue3 Ability to load variable from file - UPDATED commit f971fca2b2664c4dec0cee24225dc3c415211498 Author: Jacob McCann Date: Thu Oct 26 13:08:03 2017 -0500 Allow FilePath to take []string commit 18a556e1927fbe11c31fae47a7e3acf275ef6ae4 Author: Brad Rydzewski Date: Mon Apr 10 16:45:51 2017 +0200 fix FilePath documentation in README.md commit 4cc453ba6792515a8013340f8919e6c4b44851b7 Author: Brad Rydzewski Date: Sat Apr 1 12:55:46 2017 +0900 document field in README commit c698b821b896e9723d53c4ad1e81680f39a8cdc1 Author: Brad Rydzewski Date: Sat Apr 1 12:37:06 2017 +0900 unit tests for load from file commit 21fcab0dee7dab6969e929cf1740306bae1e16ad Author: Brad Rydzewski Date: Fri Mar 31 16:24:15 2017 +0900 ability to load variable from file commit 7f4b273a05858e05b96b6adf0a7907b7b695c352 Merge: 7bc6a0a b44660a Author: Jesse Szwedko Date: Mon Oct 30 19:55:34 2017 -0700 Merge pull request #676 from rliebz/lexicographic-sort Consider case when sorting strings commit b44660ac3da2f8e651372c40ae803782bddea283 Author: Robert Liebowitz Date: Sat Oct 28 03:00:11 2017 -0400 Consider case when sorting strings This makes sorting flags and other sections consistent with how most command line tools function, by placing both flags `-A` and `-a` before a flag `-B`. commit 7bc6a0acffa589f415f88aca16cc1de5ffd66f9c Merge: 2997500 40263f4 Author: Jesse Szwedko Date: Sat Oct 14 13:27:26 2017 -0700 Merge pull request #628 from phinnaeus/master Allow custom ExitError handler function commit 40263f4d6aaf7383fb53bd97a5c34c02be39eda8 Merge: 7233c50 2997500 Author: Tyler Davis Date: Fri Oct 13 12:05:14 2017 -0700 Merge branch 'master' into master commit 2997500ba5f393daa5d76c18544c6367b2c48d16 Merge: ac24947 c202606 Author: Jesse Szwedko Date: Sat Oct 7 13:56:23 2017 -0700 Merge pull request #672 from sierraechobravo/master fix go report card issues commit c202606a17a763fcc1b320cac6cf584662e31364 Author: Sebastian Sprenger Date: Fri Oct 6 07:29:13 2017 +0200 fix golint issues commit c3cc74dac756e33c2919ab998481809e8720e068 Author: Sebastian Sprenger Date: Fri Oct 6 07:28:43 2017 +0200 fix ineffective assigns commit 67ee172e6da2cdad8e48af107eef0fbfd1e85eec Author: Sebastian Sprenger Date: Fri Oct 6 07:28:18 2017 +0200 fix misspelling issue commit ac249472b7de27a9e8990819566d9be95ab5b816 Merge: 7fb9c86 cbbe4c1 Author: Jesse Szwedko Date: Mon Sep 25 20:41:18 2017 -0700 Merge pull request #661 from rliebz/custom-flag-help Allow customization of prefixes and environment variable hints in flag help strings commit 7233c502e31b3e6d93e3e8cf5fe0616f4d32c020 Merge: 5dc55f2 7fb9c86 Author: Tyler Davis Date: Fri Sep 22 10:08:36 2017 -0700 Merge branch 'master' into master commit cbbe4c1a2c34e52c8ad0937c01c9c15ef407a6d5 Author: Robert Liebowitz Date: Mon Sep 18 00:44:42 2017 -0400 Add tests for custom flag prefix/env hints commit 11d45572f9727acfbc93daa8565f379d396125d6 Author: rliebz Date: Sat Aug 26 07:42:25 2017 -0400 Export funcs to configure flag prefix/env hints This will allow users to customize the prefix section or env hint section of the flag entries in the help menu without having to reimplement the rest of the logic required in defining FlagStringer. commit 7fb9c86b14e6a702a4157ccb5a863f07d844a207 Merge: f017f86 1d334f1 Author: Jesse Szwedko Date: Sun Sep 10 21:08:19 2017 -0700 Merge pull request #664 from maguro/master Add newline before command categories commit 1d334f10ce73c2b9e65c50a2290a86be3c743ff2 Author: Alan D. Cabrera Date: Fri Sep 8 10:37:48 2017 -0700 Add newline before command categories The simple formatting change adds a nice blank line before each command category. Documentation in README.md is also updated to be more accurate. commit 5dc55f22878a35487bdc17393f391bf25142c6e3 Merge: 10e81ba f017f86 Author: Dan Buch Date: Sun Aug 13 12:42:49 2017 -0400 Merge branch 'master' into master commit f017f86fccc5a039a98f23311f34fdf78b014f78 Merge: cfb3883 44c6487 Author: Dan Buch Date: Sun Aug 13 10:59:49 2017 -0400 Merge pull request #659 from urfave/define-flag-precedence Define flag source precedence in README commit 44c648739b75283265541baca66ed984476a17f5 Merge: e1fa109 cfb3883 Author: Dan Buch Date: Sun Aug 13 10:54:04 2017 -0400 Merge branch 'master' into define-flag-precedence commit cfb38830724cc34fedffe9a2a29fb54fa9169cd1 Author: Jesse Szwedko Date: Thu Aug 10 18:42:03 2017 -0700 Prepare CHANGELOG for v1.20.0 release commit f5513590f52b5f90566a10ad9452f52dffd469f8 Merge: 6a70c4c b99aa81 Author: Jesse Szwedko Date: Thu Aug 10 18:06:12 2017 -0700 Merge branch 'master' into backport-json-support commit e1fa109a3195a9fedcb635841ca1907b764ada1f Author: Jesse Szwedko Date: Thu Aug 10 17:54:24 2017 -0700 Define flag source precedence in README Fixes #646 commit 688c5a9d4f3beffff9d4fa50bd85907b7067d9a4 Merge: 7250c97 4b90d79 Author: Dan Buch Date: Thu Aug 3 14:38:20 2017 -0400 Merge branch 'master' into merging-jereksel-zsh commit 10e81bacd12f5c5a44d3a3e2d6e168d0c2533245 Merge: 5d528e2 4b90d79 Author: Tyler Davis Date: Thu Jul 20 12:44:56 2017 -0700 Merge branch 'master' into master commit 5d528e2052b3e7a49293d6aa0fac245047ea61e3 Author: Tyler Davis Date: Wed Jun 28 13:04:09 2017 -0700 use exit errors in uts commit 58450552ee1bada60f4175897aff8d69f7c904a1 Author: Tyler Davis Date: Wed Jun 28 12:52:50 2017 -0700 Add Test commit 71bdf81f5a65dc253482cb727c2ae973ae3b3830 Author: Tyler Davis Date: Wed Jun 28 10:10:11 2017 -0700 sigh... fix one more named parameter issue commit 172bb92059ed885c8b4249230f3ccbe9e3e1272b Author: Tyler Davis Date: Wed Jun 28 10:07:25 2017 -0700 fix named parameter issue commit 530df59178874f8d792d2d9cfd745464076f1eda Author: Tyler Davis Date: Wed Jun 28 09:52:12 2017 -0700 Pass context into handleExitCoder commit 9d61cbad0260bc7f2a72b07142a0120072e3800a Author: Tyler Davis Date: Tue Apr 25 12:45:08 2017 -0700 Updated command.go to use App handleExitCoder commit ceee6408d5cbbb9f113157d0a62b1ffed1f2b510 Author: Tyler Davis Date: Tue Apr 25 13:02:05 2017 -0700 Revert "Fix how to do defaults in app.go" This reverts commit 8906567dc2ad52fd31c50cf02fa606505a1323ba. commit 80b09a4d1117ad69430582685e59dfe560caa948 Author: Tyler Davis Date: Tue Apr 25 11:20:41 2017 -0700 Fix how to do defaults in app.go commit 827da610b4bff0ffbc06cd2d92eddae552f7d1a2 Author: Tyler Davis Date: Tue Apr 25 09:33:54 2017 -0700 Add a bit more documentation commit 538742687bbd979a7b4f975468af76ce5cffb972 Author: Tyler Davis Date: Tue Apr 25 09:31:53 2017 -0700 Add ExitErrHandlerFunc type commit c48a82964028acd0f19ee17257789f7c9f5afc78 Author: Tyler Davis Date: Tue Apr 25 09:29:43 2017 -0700 Allow custom exit err handlers commit 6a70c4cc923c7359bacfa0500dc234d62e0ca986 Author: John Weldon Date: Sat Jul 2 12:35:48 2016 -0700 Add JSON InputSource to altsrc package - Implement NewJSONSource* functions for returning an InputSource from various JSON data sources. - Copy and modify YAML tests for the JSON InputSource Changes: * Reverted the method calls and structs to match the v1 interface commit 7250c97913c213f17c721cb3fac5e2f555b198ca Merge: 363d9c9 0bdedde Author: Dan Buch Date: Wed Dec 21 15:11:00 2016 -0500 Merge branch 'master' into merging-jereksel-zsh commit 363d9c9a314cdb9ed68cad1a27c767b45eee8840 Author: Dan Buch Date: Sun Jul 24 17:29:13 2016 -0400 Add a hack so that zsh completion only runs for zsh commit 1cbb9a7f300b11a8e5a92b1fb24d8aeb168e0275 Merge: e43a9fb ceeebab Author: Dan Buch Date: Sun Jul 24 17:12:43 2016 -0400 Merge branch 'zsh' of https://github.com/jereksel/cli into jereksel-zsh commit ceeebaba04790bab2ecd03caded488528b0caf97 Author: Andrzej Ressel Date: Thu Jul 21 00:02:16 2016 +0200 [PoC] Improve zsh autocompletions commit aba73cedacbb7b1cec2efb9962460683cd00a90c Author: jhowarth Date: Tue Mar 3 14:02:42 2015 -0800 Copy the writer of the App to the subcommand App commit a6482d268753644175e769dd91ca3a4dfe838964 Merge: b5844af 50c77ec Author: jhowarth Date: Mon Mar 2 15:21:01 2015 -0800 Merge remote-tracking branch 'upstream/master' Conflicts: app.go command.go flag.go commit b5844af29892a881ea1d22ed0082f1e0a1559bfa Merge: 8f1fb06 145da32 Author: Jesse Howarth Date: Mon Mar 2 14:53:57 2015 -0800 Merge pull request #2 from ivey/requiredFlags Required flags commit 145da3210f41f401b1f42a08385d11ee8a80ec97 Author: jhowarth Date: Mon Mar 2 12:06:42 2015 -0800 don't require flags when the help flag is included commit 6023f370c1dfea78d4ff99a6ecc6be261347bfc9 Author: jhowarth Date: Mon Mar 2 12:00:21 2015 -0800 dry error messages commit e67e05f617978eec7bba579a6c86f3d0c11ad96b Author: jhowarth Date: Mon Mar 2 11:56:29 2015 -0800 DRY error handling commit cbd95292ac9c4ba7eb30ca121fbe3825ced64f72 Author: jhowarth Date: Mon Mar 2 11:18:59 2015 -0800 Remove debugging commit 8f1fb06a585610fdb76d38bc67a5edc89da4e82f Merge: 9908e96 4b2fcdb Author: Jesse Howarth Date: Tue Dec 2 15:23:01 2014 -0800 Merge pull request #1 from ivey/required_flags Required flags commit 4b2fcdb1ade79300c56074de8e7a7bf754cd407e Author: Jesse Howarth and Michael Ivey Date: Tue Dec 2 21:08:24 2014 +0000 Add tests for required flags commit 73e64a14fde90fc3e85fdebb3647af6024e48de0 Author: Jesse Howarth and Michael Ivey Date: Tue Dec 2 19:02:56 2014 +0000 Add (required) to help of flags that are required. commit 7e0532002650b69f219f34f4614656261be45363 Author: Jesse Howarth and Michael Ivey Date: Tue Dec 2 17:44:55 2014 +0000 Implement required flags --- .github/CODEOWNERS | 4 + .gitignore | 1 + .travis.yml | 41 +- CHANGELOG.md | 111 +++- CODE_OF_CONDUCT.md | 74 +++ CONTRIBUTING.md | 18 + README.md | 366 +++++++++--- altsrc/altsrc.go | 3 - altsrc/flag.go | 16 +- altsrc/flag_generated.go | 207 ++----- altsrc/flag_test.go | 29 +- altsrc/input_source_context.go | 3 +- altsrc/json_command_test.go | 29 +- altsrc/json_source_context.go | 18 +- altsrc/map_input_source.go | 17 +- altsrc/toml_command_test.go | 63 +- altsrc/toml_file_loader.go | 10 +- altsrc/yaml_command_test.go | 47 +- altsrc/yaml_file_loader.go | 6 +- app.go | 195 +++++-- app_test.go | 598 +++++++++++++++++-- appveyor.yml | 29 +- autocomplete/bash_autocomplete | 11 +- autocomplete/zsh_autocomplete | 14 +- build.go | 164 ++++++ category.go | 6 +- cli.go | 2 +- command.go | 52 +- command_test.go | 155 ++++- context.go | 170 ++++-- context_test.go | 286 +++++++++- docs.go | 148 +++++ docs_test.go | 122 ++++ errors.go | 16 +- fish.go | 194 +++++++ fish_test.go | 17 + flag-types.json | 98 ---- flag.go | 826 ++++----------------------- flag_bool.go | 107 ++++ flag_duration.go | 104 ++++ flag_float64.go | 106 ++++ flag_float64_slice.go | 164 ++++++ flag_generated.go | 629 -------------------- flag_generic.go | 104 ++++ flag_int.go | 103 ++++ flag_int64.go | 103 ++++ flag_int64_slice.go | 164 ++++++ flag_int_slice.go | 175 ++++++ flag_path.go | 85 +++ flag_string.go | 95 +++ flag_string_slice.go | 155 +++++ flag_test.go | 546 +++++++++++------- flag_uint.go | 104 ++++ flag_uint64.go | 104 ++++ funcs.go | 20 +- generate-flag-types | 255 --------- go.mod | 9 + go.sum | 14 + help.go | 126 +++- help_test.go | 46 +- helpers_unix_test.go | 9 - helpers_windows_test.go | 20 - parse.go | 80 +++ runtests | 172 ------ sort.go | 29 + sort_test.go | 30 + template.go | 121 ++++ testdata/expected-doc-full.man | 80 +++ testdata/expected-doc-full.md | 62 ++ testdata/expected-doc-no-commands.md | 36 ++ testdata/expected-doc-no-flags.md | 47 ++ testdata/expected-fish-full.fish | 28 + 72 files changed, 5464 insertions(+), 2734 deletions(-) create mode 100644 .github/CODEOWNERS create mode 100644 CODE_OF_CONDUCT.md create mode 100644 CONTRIBUTING.md delete mode 100644 altsrc/altsrc.go create mode 100644 build.go create mode 100644 docs.go create mode 100644 docs_test.go create mode 100644 fish.go create mode 100644 fish_test.go delete mode 100644 flag-types.json create mode 100644 flag_bool.go create mode 100644 flag_duration.go create mode 100644 flag_float64.go create mode 100644 flag_float64_slice.go delete mode 100644 flag_generated.go create mode 100644 flag_generic.go create mode 100644 flag_int.go create mode 100644 flag_int64.go create mode 100644 flag_int64_slice.go create mode 100644 flag_int_slice.go create mode 100644 flag_path.go create mode 100644 flag_string.go create mode 100644 flag_string_slice.go create mode 100644 flag_uint.go create mode 100644 flag_uint64.go delete mode 100755 generate-flag-types create mode 100644 go.mod create mode 100644 go.sum delete mode 100644 helpers_unix_test.go delete mode 100644 helpers_windows_test.go create mode 100644 parse.go delete mode 100755 runtests create mode 100644 sort.go create mode 100644 sort_test.go create mode 100644 template.go create mode 100644 testdata/expected-doc-full.man create mode 100644 testdata/expected-doc-full.md create mode 100644 testdata/expected-doc-no-commands.md create mode 100644 testdata/expected-doc-no-flags.md create mode 100644 testdata/expected-fish-full.fish diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..4f138e8 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,4 @@ +# See https://help.github.com/articles/about-codeowners/ +# for more info about CODEOWNERS file + +* @urfave/cli diff --git a/.gitignore b/.gitignore index faf70c4..7a7e2d9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ *.coverprofile node_modules/ +vendor \ No newline at end of file diff --git a/.travis.yml b/.travis.yml index 58ed292..e500b38 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,28 +1,35 @@ language: go sudo: false -dist: trusty -osx_image: xcode8.3 -go: 1.11.x +dist: bionic +osx_image: xcode10 +go: + - 1.11.x + - 1.12.x + - 1.13.x os: -- linux -- osx + - linux + - osx + +env: + GO111MODULE=on + GOPROXY=https://proxy.golang.org cache: directories: - - node_modules + - node_modules before_script: -- if [[ $(uname) == Darwin ]]; then - sudo pip2 install flake8; - else - pip install --user flake8; - fi -- mkdir -p ${GOPATH%%:*}/src/gopkg.in/urfave -- rm -rvf ${GOPATH%%:*}/src/gopkg.in/urfave/cli.v2 -- rm -rvf ${GOPATH%%:*}/pkg/*/gopkg.in/urfave/cli.v2.a -- ln -sv ${TRAVIS_BUILD_DIR} ${GOPATH%%:*}/src/gopkg.in/urfave/cli.v2 + - go get github.com/urfave/gfmrun/cmd/gfmrun + - go get golang.org/x/tools/cmd/goimports + - npm install markdown-toc + - go mod tidy script: -- flake8 runtests cli-v1-to-v2 generate-flag-types -- make all + - go run build.go vet + - go run build.go test + - go run build.go gfmrun + - go run build.go toc + +after_success: + - bash <(curl -s https://codecov.io/bash) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5fa0ca0..d1b5c61 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -39,11 +39,110 @@ ### Removed +## [1.22.1] - 2019-09-11 + ### Fixed -### Deprecated +* Hide output of hidden commands on man pages in [urfave/cli/pull/889](https://github.com/urfave/cli/pull/889) via [@crosbymichael](https://github.com/crosbymichael) +* Don't generate fish completion for hidden commands [urfave/cli/pull/891](https://github.com/urfave/891) via [@saschagrunert](https://github.com/saschagrunert) +* Using short flag names for required flags throws an error in [urfave/cli/pull/890](https://github.com/urfave/cli/pull/890) via [@asahasrabuddhe](https://github.com/asahasrabuddhe) + +### Changed + +* Remove flag code generation logic, legacy python test runner in [urfave/cli/pull/883](https://github.com/urfave/cli/pull/883) via [@asahasrabuddhe](https://github.com/asahasrabuddhe) +* Enable Go Modules support, drop support for `Go 1.10` add support for `Go 1.13` in [urfave/cli/pull/885](https://github.com/urfave/cli/pull/885) via [@asahasrabuddhe](https://github.com/asahasrabuddhe) + +## [1.22.0] - 2019-09-07 + +### Fixed + +* Fix Subcommands not falling back to `app.ExitEventHandler` in [urfave/cli/pull/856](https://github.com/urfave/cli/pull/856) via [@FaranIdo](https://github.com/FaranIdo) + +### Changed + +* Clarify that altsrc supports both TOML and JSON in [urfave/cli/pull/774](https://github.com/urfave/cli/pull/774) via [@whereswaldon](https://github.com/whereswaldon) +* Made the exit code example more clear in [urfave/cli/pull/823](https://github.com/urfave/cli/pull/823) via [@xordspar0](https://github.com/xordspar0) +* Removed the use of python for internal flag generation in [urfave/cli/pull/836](https://github.com/urfave/cli/pull/836) via [@asahasrabuddhe](https://github.com/asahasrabuddhe) +* Changed the supported go versions to `1.10`, `1.11`, `1.12` in [urfave/cli/pull/843](https://github.com/urfave/cli/pull/843) via [@lafriks](https://github.com/lafriks) +* Changed the v1 releases section in the readme in [urfave/cli/pull/862](https://github.com/urfave/cli/pull/862) via [@russoj88](https://github.com/russoj88) +* Cleaned up go modules in [urfave/cli/pull/874](https://github.com/urfave/cli/pull/874) via [@saschagrunert](https://github.com/saschagrunert) + +### Added + +* Added `UseShortOptionHandling` for combining short flags in [urfave/cli/pull/735](https://github.com/urfave/cli/pull/735) via [@rliebz](https://github.com/rliebz) +* Added support for flags bash completion in [urfave/cli/pull/808](https://github.com/urfave/cli/pull/808) via [@yogeshlonkar](https://github.com/yogeshlonkar) +* Added the `TakesFile` indicator to flag in [urfave/cli/pull/851](https://github.com/urfave/cli/pull/851) via [@saschagrunert](https://github.com/saschagrunert) +* Added fish shell completion support in [urfave/cli/pull/848](https://github.com/urfave/cli/pull/848) via [@saschagrunert](https://github.com/saschagrunert) + +## [1.21.0] - 2019-08-02 + +### Fixed + +* Fix using "slice" flag types with `EnvVar` in [urfave/cli/pull/687](https://github.com/urfave/cli/pull/687) via [@joshuarubin](https://github.com/joshuarubin) +* Fix regression of `SkipFlagParsing` behavior in [urfave/cli/pull/697](https://github.com/urfave/cli/pull/697) via [@jszwedko](https://github.com/jszwedko) +* Fix handling `ShortOptions` and `SkipArgReorder` in [urfave/cli/pull/686](https://github.com/urfave/cli/pull/686) via [@baude](https://github.com/baude) +* Fix args reordering when bool flags are present in [urfave/cli/pull/712](https://github.com/urfave/cli/pull/712) via [@windler](https://github.com/windler) +* Fix parsing of short options in [urfave/cli/pull/758](https://github.com/urfave/cli/pull/758) via [@vrothberg](https://github.com/vrothberg) +* Fix unaligned indents for the command help messages in [urfave/cli/pull/806](https://github.com/urfave/cli/pull/806) via [@mingrammer](https://github.com/mingrammer) + +### Changed + +* Cleaned up help output in [urfave/cli/pull/664](https://github.com/urfave/cli/pull/664) via [@maguro](https://github.com/maguro) +* Remove redundant nil checks in [urfave/cli/pull/773](https://github.com/urfave/cli/pull/773) via [@teresy](https://github.com/teresy) +* Case is now considered when sorting strings in [urfave/cli/pull/676](https://github.com/urfave/cli/pull/676) via [@rliebz](https://github.com/rliebz) + +### Added + +* Added _"required flags"_ support in [urfave/cli/pull/819](https://github.com/urfave/cli/pull/819) via [@lynncyrin](https://github.com/lynncyrin/) +* Backport JSON `InputSource` to v1 in [urfave/cli/pull/598](https://github.com/urfave/cli/pull/598) via [@jszwedko](https://github.com/jszwedko) +* Allow more customization of flag help strings in [urfave/cli/pull/661](https://github.com/urfave/cli/pull/661) via [@rliebz](https://github.com/rliebz) +* Allow custom `ExitError` handler function in [urfave/cli/pull/628](https://github.com/urfave/cli/pull/628) via [@phinnaeus](https://github.com/phinnaeus) +* Allow loading a variable from a file in [urfave/cli/pull/675](https://github.com/urfave/cli/pull/675) via [@jmccann](https://github.com/jmccann) +* Allow combining short bool names in [urfave/cli/pull/684](https://github.com/urfave/cli/pull/684) via [@baude](https://github.com/baude) +* Added test coverage to context in [urfave/cli/pull/788](https://github.com/urfave/cli/pull/788) via [@benzvan](https://github.com/benzvan) +* Added go module support in [urfave/cli/pull/831](https://github.com/urfave/cli/pull/831) via [@saschagrunert](https://github.com/saschagrunert) + +## [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 -### Security +* `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 @@ -403,7 +502,13 @@ signature of `func(*cli.Context) error`, as defined by `cli.ActionFunc`. ### Added - Initial implementation. -[Unreleased]: https://github.com/urfave/cli/compare/v1.18.0...HEAD +[Unreleased]: https://github.com/urfave/cli/compare/v1.22.1...HEAD +[1.22.1]: https://github.com/urfave/cli/compare/v1.22.0...v1.22.1 +[1.22.0]: https://github.com/urfave/cli/compare/v1.21.0...v1.22.0 +[1.21.0]: https://github.com/urfave/cli/compare/v1.20.0...v1.21.0 +[1.20.0]: https://github.com/urfave/cli/compare/v1.19.1...v1.20.0 +[1.19.1]: https://github.com/urfave/cli/compare/v1.19.0...v1.19.1 +[1.19.0]: https://github.com/urfave/cli/compare/v1.18.0...v1.19.0 [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 diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..41ba294 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -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 + diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..9a4640a --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,18 @@ +## Contributing + +Use @urfave/cli to ping the maintainers. + +Feel free to put up a pull request to fix a bug or maybe add a feature. We will +give it a code review and make sure that it does not break backwards +compatibility. If 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! diff --git a/README.md b/README.md index dbe1bf3..7624c48 100644 --- a/README.md +++ b/README.md @@ -3,15 +3,11 @@ cli [![Build Status](https://travis-ci.org/urfave/cli.svg?branch=master)](https://travis-ci.org/urfave/cli) [![Windows Build Status](https://ci.appveyor.com/api/projects/status/rtgk5xufi932pb2v?svg=true)](https://ci.appveyor.com/project/urfave/cli) + [![GoDoc](https://godoc.org/github.com/urfave/cli?status.svg)](https://godoc.org/github.com/urfave/cli) [![codebeat](https://codebeat.co/badges/0a8f30aa-f975-404b-b878-5fab3ae1cc5f)](https://codebeat.co/projects/github-com-urfave-cli) [![Go Report Card](https://goreportcard.com/badge/urfave/cli)](https://goreportcard.com/report/urfave/cli) -[![top level coverage](https://gocover.io/_badge/github.com/urfave/cli?0 "top level coverage")](http://gocover.io/github.com/urfave/cli) / -[![altsrc coverage](https://gocover.io/_badge/github.com/urfave/cli/altsrc?0 "altsrc coverage")](http://gocover.io/github.com/urfave/cli/altsrc) - -**Notice:** This is the library formerly known as -`github.com/codegangsta/cli` -- Github will automatically redirect requests -to this repository, but we recommend updating your references for clarity. +[![codecov](https://codecov.io/gh/urfave/cli/branch/master/graph/badge.svg)](https://codecov.io/gh/urfave/cli) cli is a simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line @@ -23,7 +19,7 @@ applications in an expressive way. - [Installation](#installation) * [Supported platforms](#supported-platforms) * [Using the `v2` branch](#using-the-v2-branch) - * [Pinning to the `v1` releases](#pinning-to-the-v1-releases) + * [Using `v1` releases](#using-v1-releases) - [Getting Started](#getting-started) - [Examples](#examples) * [Arguments](#arguments) @@ -32,12 +28,22 @@ applications in an expressive way. + [Alternate Names](#alternate-names) + [Ordering](#ordering) + [Values from the Environment](#values-from-the-environment) + + [Values from files](#values-from-files) + [Values from alternate input sources (YAML, TOML, and others)](#values-from-alternate-input-sources-yaml-toml-and-others) +<<<<<<< HEAD + [Default Values for help output](#default-values-for-help-output) * [Subcommands](#subcommands) * [Subcommands categories](#subcommands-categories) * [Exit code](#exit-code) * [Shell Completion](#shell-completion) +======= + + [Precedence](#precedence) + * [Subcommands](#subcommands) + * [Subcommands categories](#subcommands-categories) + * [Exit code](#exit-code) + * [Combining short options](#combining-short-options) + * [Bash Completion](#bash-completion) +>>>>>>> master + [Enabling](#enabling) + [Distribution](#distribution) + [Customization](#customization) @@ -62,12 +68,12 @@ organized, and expressive! ## Installation -Make sure you have a working Go environment. Go version 1.2+ is supported. [See +Make sure you have a working Go environment. Go version 1.10+ is supported. [See the install instructions for Go](http://golang.org/doc/install.html). To install cli, simply run: ``` -$ go get github.com/urfave/cli +$ go get github.com/urfave/cli/v2 ``` Make sure your `PATH` includes the `$GOPATH/bin` directory so your commands can @@ -91,21 +97,21 @@ the new `master` branch once development there has settled down. The current `master` branch (mirrored as `v1`) is being manually merged into `v2` on an irregular human-based schedule, but generally if one wants to "upgrade" to `v2` *now* and accept the volatility (read: "awesomeness") that comes along with -that, please use whatever version pinning of your preference, such as via -`gopkg.in`: +that, please use: ``` -$ go get gopkg.in/urfave/cli.v2 +$ go get github.com/urfave/cli/v2 ``` ``` go ... import ( - "gopkg.in/urfave/cli.v2" // imports as package "cli" + "github.com/urfave/cli/v2" // imports as package "cli" ) ... ``` +<<<<<<< HEAD **NOTE**: There is a [migrator (python) script](./cli-v1-to-v2) available to aid with the transition from the v1 to v2 API. @@ -114,20 +120,22 @@ with the transition from the v1 to v2 API. Similarly to the section above describing use of the `v2` branch, if one wants to avoid any unexpected compatibility pains once `v2` becomes `master`, then pinning to `v1` is an acceptable option, e.g.: +======= +### Using `v1` releases +>>>>>>> master ``` -$ go get gopkg.in/urfave/cli.v1 +$ go get github.com/urfave/cli ``` -``` go +```go ... import ( - "gopkg.in/urfave/cli.v1" // imports as package "cli" + "github.com/urfave/cli/v2" ) ... ``` -This will pull the latest tagged `v1` release (e.g. `v1.18.1` at the time of writing). ## Getting Started @@ -142,9 +150,10 @@ discovery. So a cli app can be as little as one line of code in `main()`. package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -163,9 +172,10 @@ package main import ( "fmt" + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -178,7 +188,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -202,9 +215,10 @@ package main import ( "fmt" + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -217,7 +231,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -266,9 +283,10 @@ package main import ( "fmt" + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -279,7 +297,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -295,9 +316,10 @@ package main import ( "fmt" + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -323,7 +345,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -337,10 +362,11 @@ scanned. package main import ( + "log" "os" "fmt" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -369,7 +395,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -390,9 +419,10 @@ For example this: package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -406,7 +436,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -432,9 +465,10 @@ list for the `Name`. e.g. package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -449,7 +483,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -473,10 +510,11 @@ For example this: package main import ( + "log" "os" "sort" - "github.com/urfave/cli" + "github.com/urfave/cli/v2" ) func main() { @@ -515,7 +553,10 @@ func main() { sort.Sort(cli.FlagsByName(app.Flags)) sort.Sort(cli.CommandsByName(app.Commands)) - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -538,9 +579,10 @@ You can also have the default value set from the environment via `EnvVars`. e.g package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -556,7 +598,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -571,9 +616,10 @@ resolves is used as the default. package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -589,10 +635,52 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` +#### Values from files + +You can also have the default value set from file via `FilePath`. e.g. + + +``` go +package main + +import ( + "log" + "os" + + "github.com/urfave/cli/v2" +) + +func main() { + app := cli.NewApp() + + app.Flags = []cli.Flag { + cli.StringFlag{ + Name: "password, p", + Usage: "password for the mysql database", + FilePath: "/etc/mysql/password", + }, + } + + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } +} +``` + +Note that default values set from file (e.g. `FilePath`) take precedence over +default values set from the environment (e.g. `EnvVar`). + #### Values from alternate input sources (YAML, TOML, and others) There is a separate package altsrc that adds support for getting flag values @@ -600,6 +688,7 @@ from other file input sources. Currently supported input source formats: * YAML +* JSON * TOML In order to get values for a flag from an alternate input source the following @@ -622,9 +711,9 @@ the yaml input source for any flags that are defined on that command. As a note the "load" flag used would also have to be defined on the command flags in order for this code snipped to work. -Currently only the aboved specified formats are supported but developers can -add support for other input sources by implementing the -altsrc.InputSourceContext for their given sources. +Currently only YAML, JSON, and TOML files are supported but developers can add support +for other input sources by implementing the altsrc.InputSourceContext for their +given sources. Here is a more complete sample of a command using YAML support: @@ -637,10 +726,11 @@ package notmain import ( "fmt" + "log" "os" - "gopkg.in/urfave/cli.v2" - "gopkg.in/urfave/cli.v2/altsrc" + "github.com/urfave/cli/v2" + "github.com/urfave/cli/v2/altsrc" ) func main() { @@ -678,7 +768,7 @@ package main import ( "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -693,7 +783,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -703,6 +796,14 @@ Will result in help output like: --port value Use a randomized port (default: random) ``` +#### Precedence + +The precedence for flag value sources is as follows (highest to lowest): + +0. Command line flag value from user +0. Environment variable (if specified) +0. Configuration file (if specified) +0. Default defined on the flag ### Subcommands @@ -717,9 +818,10 @@ package main import ( "fmt" + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -769,7 +871,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -785,9 +890,10 @@ E.g. package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -807,7 +913,10 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -815,7 +924,7 @@ Will include: ``` COMMANDS: - noop + noop Template actions: add @@ -828,14 +937,17 @@ Calling `App.Run` will not automatically call `os.Exit`, which means that by default the exit code will "fall through" to being `0`. An explicit exit code may be set by returning a non-nil error that fulfills `cli.ExitCoder`, *or* a `cli.MultiError` that includes an error that fulfills `cli.ExitCoder`, e.g.: - + ``` go package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -855,13 +967,86 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` -### Shell Completion +### Combining short options + +Traditional use of options using their shortnames look like this: + +``` +$ cmd -s -o -m "Some message" +``` + +Suppose you want users to be able to combine options with their shortnames. This +can be done using the `UseShortOptionHandling` bool in your app configuration, +or for individual commands by attaching it to the command configuration. For +example: + + +``` go +package main + +import ( + "fmt" + "log" + "os" + + "github.com/urfave/cli/v2" +) + +func main() { + app := &cli.App{} + app.UseShortOptionHandling = true + app.Commands = []*cli.Command{ + { + Name: "short", + Usage: "complete a task on the list", + Flags: []cli.Flag{ + cli.BoolFlag{Name: "serve, s"}, + cli.BoolFlag{Name: "option, o"}, + cli.StringFlag{Name: "message, m"}, + }, + Action: func(c *cli.Context) error { + fmt.Println("serve:", c.Bool("serve")) + fmt.Println("option:", c.Bool("option")) + fmt.Println("message:", c.String("message")) + return nil + }, + }, + } -You can enable completion commands by setting the `EnableShellCompletion` + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } +} +``` + +If your program has any number of bool flags such as `serve` and `option`, and +optionally one non-bool flag `message`, with the short options of `-s`, `-o`, +and `-m` respectively, setting `UseShortOptionHandling` will also support the +following syntax: + +``` +$ cmd -som "Some message" +``` + +If you enable `UseShortOptionHandling`, then you must not use any flags that +have a single leading `-` or this will result in failures. For example, +`-option` can no longer be used. Flags with two leading dashes (such as +`--options`) are still valid. + +### Bash Completion + +You can enable completion commands by setting the `EnableBashCompletion` flag on the `App` object. By default, this setting will only auto-complete to show an app's subcommands, but you can write your own completion methods for the App or its subcommands. @@ -875,16 +1060,17 @@ package main import ( "fmt" + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { tasks := []string{"cook", "clean", "laundry", "eat", "sleep", "code"} app := &cli.App{ - EnableShellCompletion: true, + EnableBashCompletion: true, Commands: []*cli.Command{ { Name: "complete", @@ -894,7 +1080,7 @@ func main() { fmt.Println("completed task: ", c.Args().First()) return nil }, - ShellComplete: func(c *cli.Context) { + BashComplete: func(c *cli.Context) { // This will complete if no args are passed if c.NArg() > 0 { return @@ -907,23 +1093,19 @@ func main() { }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` #### Enabling -You can generate bash or zsh completion code by using the flag `--init-completion bash` or `--init-completion zsh`. +Source the `autocomplete/bash_autocomplete` file in your .bashrc file while setting the `PROG` variable to the name of your program: -To setup for bash: - -``` -eval "`myprogram --init-completion bash`" -``` - -Alternatively, you can put the completion code in your `.bashrc` file: ``` -myprogram --init-completion bash >> ~/.bashrc +PROG=myprogram source /.../cli/autocomplete/bash_autocomplete ``` #### Distribution @@ -955,9 +1137,10 @@ The default shell completion flag (`--generate-completion`) is defined as package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -974,7 +1157,10 @@ func main() { }, }, } - app.Run(os.Args) + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } } ``` @@ -1000,10 +1186,11 @@ package main import ( "fmt" + "log" "io" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -1042,7 +1229,7 @@ VERSION: cli.HelpPrinter = func(w io.Writer, templ string, data interface{}) { fmt.Println("Ha HA. I pwnd the help!!1") } - + (&cli.App{}).Run(os.Args) } ``` @@ -1058,9 +1245,10 @@ setting `cli.HelpFlag`, e.g.: package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -1069,7 +1257,7 @@ func main() { Usage: "HALP", EnvVars: []string{"SHOW_HALP", "HALPPLZ"}, } - + (&cli.App{}).Run(os.Args) } ``` @@ -1093,9 +1281,10 @@ setting `cli.VersionFlag`, e.g.: package main import ( + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func main() { @@ -1103,7 +1292,7 @@ func main() { Name: "print-version", Aliases: []string{"V"}, Usage: "print only the version", } - + app := &cli.App{ Name: "partay", Version: "v19.99.0", @@ -1123,9 +1312,10 @@ package main import ( "fmt" + "log" "os" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) var ( @@ -1136,7 +1326,7 @@ func main() { cli.VersionPrinter = func(c *cli.Context) { fmt.Printf("version=%s revision=%s\n", c.App.Version, Revision) } - + app := &cli.App{ Name: "partay", Version: "v19.99.0", @@ -1165,7 +1355,7 @@ import ( "os" "time" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func init() { @@ -1217,7 +1407,7 @@ func (g *genericType) String() string { } func main() { - app := cli.App{ + app := &cli.App{ Name: "kənˈtrīv", Version: "v19.99.0", Compiled: time.Now(), @@ -1406,7 +1596,7 @@ func main() { app.Writer = &hexWriter{} app.ErrWriter = &hexWriter{} } - + app.Run(os.Args) } @@ -1418,16 +1608,4 @@ func wopAction(c *cli.Context) error { ## Contribution Guidelines -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, please open an issue. +See [./CONTRIBUTING.md](./CONTRIBUTING.md) diff --git a/altsrc/altsrc.go b/altsrc/altsrc.go deleted file mode 100644 index ac34bf6..0000000 --- a/altsrc/altsrc.go +++ /dev/null @@ -1,3 +0,0 @@ -package altsrc - -//go:generate python ../generate-flag-types altsrc -i ../flag-types.json -o flag_generated.go diff --git a/altsrc/flag.go b/altsrc/flag.go index 858e54e..31b8a04 100644 --- a/altsrc/flag.go +++ b/altsrc/flag.go @@ -6,7 +6,7 @@ import ( "strconv" "syscall" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) // FlagInputSourceExtension is an extension interface of cli.Flag that @@ -72,7 +72,7 @@ func (f *GenericFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourc } if value != nil { for _, name := range f.Names() { - f.set.Set(name, value.String()) + _ = f.set.Set(name, value.String()) } } } @@ -135,7 +135,7 @@ func (f *BoolFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceCo } if value { for _, name := range f.Names() { - f.set.Set(name, strconv.FormatBool(value)) + _ = f.set.Set(name, strconv.FormatBool(value)) } } } @@ -153,7 +153,7 @@ func (f *StringFlag) ApplyInputSourceValue(context *cli.Context, isc InputSource } if value != "" { for _, name := range f.Names() { - f.set.Set(name, value) + _ = f.set.Set(name, value) } } } @@ -181,7 +181,7 @@ func (f *PathFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceCo value = filepath.Join(filepath.Dir(basePathAbs), value) } - f.set.Set(name, value) + _ = f.set.Set(name, value) } } } @@ -199,7 +199,7 @@ func (f *IntFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceCon } if value > 0 { for _, name := range f.Names() { - f.set.Set(name, strconv.FormatInt(int64(value), 10)) + _ = f.set.Set(name, strconv.FormatInt(int64(value), 10)) } } } @@ -217,7 +217,7 @@ func (f *DurationFlag) ApplyInputSourceValue(context *cli.Context, isc InputSour } if value > 0 { for _, name := range f.Names() { - f.set.Set(name, value.String()) + _ = f.set.Set(name, value.String()) } } } @@ -236,7 +236,7 @@ func (f *Float64Flag) ApplyInputSourceValue(context *cli.Context, isc InputSourc if value > 0 { floatStr := float64ToString(value) for _, name := range f.Names() { - f.set.Set(name, floatStr) + _ = f.set.Set(name, floatStr) } } } diff --git a/altsrc/flag_generated.go b/altsrc/flag_generated.go index 87c7c5d..de3e2b5 100644 --- a/altsrc/flag_generated.go +++ b/altsrc/flag_generated.go @@ -2,12 +2,9 @@ package altsrc import ( "flag" - - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) -// WARNING: This file is generated! - // BoolFlag is the flag type that wraps cli.BoolFlag to allow // for other values to be specified type BoolFlag struct { @@ -20,18 +17,11 @@ func NewBoolFlag(fl *cli.BoolFlag) *BoolFlag { return &BoolFlag{BoolFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped BoolFlag.Apply -func (f *BoolFlag) Apply(set *flag.FlagSet) { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped BoolFlag.Apply +func (f *BoolFlag) Apply(set *flag.FlagSet) error { f.set = set - f.BoolFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped BoolFlag.ApplyWithError -func (f *BoolFlag) ApplyWithError(set *flag.FlagSet) error { - f.set = set - return f.BoolFlag.ApplyWithError(set) + return f.BoolFlag.Apply(set) } // DurationFlag is the flag type that wraps cli.DurationFlag to allow @@ -46,18 +36,11 @@ func NewDurationFlag(fl *cli.DurationFlag) *DurationFlag { return &DurationFlag{DurationFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped DurationFlag.Apply -func (f *DurationFlag) Apply(set *flag.FlagSet) { - f.set = set - f.DurationFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped DurationFlag.ApplyWithError -func (f *DurationFlag) ApplyWithError(set *flag.FlagSet) error { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped DurationFlag.Apply +func (f *DurationFlag) Apply(set *flag.FlagSet) error { f.set = set - return f.DurationFlag.ApplyWithError(set) + return f.DurationFlag.Apply(set) } // Float64Flag is the flag type that wraps cli.Float64Flag to allow @@ -72,18 +55,11 @@ func NewFloat64Flag(fl *cli.Float64Flag) *Float64Flag { return &Float64Flag{Float64Flag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped Float64Flag.Apply -func (f *Float64Flag) Apply(set *flag.FlagSet) { - f.set = set - f.Float64Flag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped Float64Flag.ApplyWithError -func (f *Float64Flag) ApplyWithError(set *flag.FlagSet) error { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped Float64Flag.Apply +func (f *Float64Flag) Apply(set *flag.FlagSet) error { f.set = set - return f.Float64Flag.ApplyWithError(set) + return f.Float64Flag.Apply(set) } // GenericFlag is the flag type that wraps cli.GenericFlag to allow @@ -98,18 +74,11 @@ func NewGenericFlag(fl *cli.GenericFlag) *GenericFlag { return &GenericFlag{GenericFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped GenericFlag.Apply -func (f *GenericFlag) Apply(set *flag.FlagSet) { - f.set = set - f.GenericFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped GenericFlag.ApplyWithError -func (f *GenericFlag) ApplyWithError(set *flag.FlagSet) error { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped GenericFlag.Apply +func (f *GenericFlag) Apply(set *flag.FlagSet) error { f.set = set - return f.GenericFlag.ApplyWithError(set) + return f.GenericFlag.Apply(set) } // Int64Flag is the flag type that wraps cli.Int64Flag to allow @@ -124,18 +93,11 @@ func NewInt64Flag(fl *cli.Int64Flag) *Int64Flag { return &Int64Flag{Int64Flag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped Int64Flag.Apply -func (f *Int64Flag) Apply(set *flag.FlagSet) { - f.set = set - f.Int64Flag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped Int64Flag.ApplyWithError -func (f *Int64Flag) ApplyWithError(set *flag.FlagSet) error { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped Int64Flag.Apply +func (f *Int64Flag) Apply(set *flag.FlagSet) error { f.set = set - return f.Int64Flag.ApplyWithError(set) + return f.Int64Flag.Apply(set) } // IntFlag is the flag type that wraps cli.IntFlag to allow @@ -150,18 +112,11 @@ func NewIntFlag(fl *cli.IntFlag) *IntFlag { return &IntFlag{IntFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped IntFlag.Apply -func (f *IntFlag) Apply(set *flag.FlagSet) { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped IntFlag.Apply +func (f *IntFlag) Apply(set *flag.FlagSet) error { f.set = set - f.IntFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped IntFlag.ApplyWithError -func (f *IntFlag) ApplyWithError(set *flag.FlagSet) error { - f.set = set - return f.IntFlag.ApplyWithError(set) + return f.IntFlag.Apply(set) } // IntSliceFlag is the flag type that wraps cli.IntSliceFlag to allow @@ -176,18 +131,11 @@ func NewIntSliceFlag(fl *cli.IntSliceFlag) *IntSliceFlag { return &IntSliceFlag{IntSliceFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped IntSliceFlag.Apply -func (f *IntSliceFlag) Apply(set *flag.FlagSet) { - f.set = set - f.IntSliceFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped IntSliceFlag.ApplyWithError -func (f *IntSliceFlag) ApplyWithError(set *flag.FlagSet) error { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped IntSliceFlag.Apply +func (f *IntSliceFlag) Apply(set *flag.FlagSet) error { f.set = set - return f.IntSliceFlag.ApplyWithError(set) + return f.IntSliceFlag.Apply(set) } // Int64SliceFlag is the flag type that wraps cli.Int64SliceFlag to allow @@ -202,18 +150,11 @@ func NewInt64SliceFlag(fl *cli.Int64SliceFlag) *Int64SliceFlag { return &Int64SliceFlag{Int64SliceFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped Int64SliceFlag.Apply -func (f *Int64SliceFlag) Apply(set *flag.FlagSet) { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped Int64SliceFlag.Apply +func (f *Int64SliceFlag) Apply(set *flag.FlagSet) error { f.set = set - f.Int64SliceFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped Int64SliceFlag.ApplyWithError -func (f *Int64SliceFlag) ApplyWithError(set *flag.FlagSet) error { - f.set = set - return f.Int64SliceFlag.ApplyWithError(set) + return f.Int64SliceFlag.Apply(set) } // Float64SliceFlag is the flag type that wraps cli.Float64SliceFlag to allow @@ -230,16 +171,9 @@ func NewFloat64SliceFlag(fl *cli.Float64SliceFlag) *Float64SliceFlag { // Apply saves the flagSet for later usage calls, then calls the // wrapped Float64SliceFlag.Apply -func (f *Float64SliceFlag) Apply(set *flag.FlagSet) { - f.set = set - f.Float64SliceFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped Float64SliceFlag.ApplyWithError -func (f *Float64SliceFlag) ApplyWithError(set *flag.FlagSet) error { +func (f *Float64SliceFlag) Apply(set *flag.FlagSet) error { f.set = set - return f.Float64SliceFlag.ApplyWithError(set) + return f.Float64SliceFlag.Apply(set) } // StringFlag is the flag type that wraps cli.StringFlag to allow @@ -254,18 +188,11 @@ func NewStringFlag(fl *cli.StringFlag) *StringFlag { return &StringFlag{StringFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped StringFlag.Apply -func (f *StringFlag) Apply(set *flag.FlagSet) { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped StringFlag.Apply +func (f *StringFlag) Apply(set *flag.FlagSet) error { f.set = set - f.StringFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped StringFlag.ApplyWithError -func (f *StringFlag) ApplyWithError(set *flag.FlagSet) error { - f.set = set - return f.StringFlag.ApplyWithError(set) + return f.StringFlag.Apply(set) } // PathFlag is the flag type that wraps cli.PathFlag to allow @@ -282,16 +209,9 @@ func NewPathFlag(fl *cli.PathFlag) *PathFlag { // Apply saves the flagSet for later usage calls, then calls the // wrapped PathFlag.Apply -func (f *PathFlag) Apply(set *flag.FlagSet) { - f.set = set - f.PathFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped PathFlag.ApplyWithError -func (f *PathFlag) ApplyWithError(set *flag.FlagSet) error { +func (f *PathFlag) Apply(set *flag.FlagSet) error { f.set = set - return f.PathFlag.ApplyWithError(set) + return f.PathFlag.Apply(set) } // StringSliceFlag is the flag type that wraps cli.StringSliceFlag to allow @@ -306,18 +226,11 @@ func NewStringSliceFlag(fl *cli.StringSliceFlag) *StringSliceFlag { return &StringSliceFlag{StringSliceFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped StringSliceFlag.Apply -func (f *StringSliceFlag) Apply(set *flag.FlagSet) { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped StringSliceFlag.Apply +func (f *StringSliceFlag) Apply(set *flag.FlagSet) error { f.set = set - f.StringSliceFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped StringSliceFlag.ApplyWithError -func (f *StringSliceFlag) ApplyWithError(set *flag.FlagSet) error { - f.set = set - return f.StringSliceFlag.ApplyWithError(set) + return f.StringSliceFlag.Apply(set) } // Uint64Flag is the flag type that wraps cli.Uint64Flag to allow @@ -332,18 +245,11 @@ func NewUint64Flag(fl *cli.Uint64Flag) *Uint64Flag { return &Uint64Flag{Uint64Flag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped Uint64Flag.Apply -func (f *Uint64Flag) Apply(set *flag.FlagSet) { - f.set = set - f.Uint64Flag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped Uint64Flag.ApplyWithError -func (f *Uint64Flag) ApplyWithError(set *flag.FlagSet) error { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped Uint64Flag.Apply +func (f *Uint64Flag) Apply(set *flag.FlagSet) error { f.set = set - return f.Uint64Flag.ApplyWithError(set) + return f.Uint64Flag.Apply(set) } // UintFlag is the flag type that wraps cli.UintFlag to allow @@ -358,16 +264,9 @@ func NewUintFlag(fl *cli.UintFlag) *UintFlag { return &UintFlag{UintFlag: fl, set: nil} } -// Apply saves the flagSet for later usage calls, then calls the -// wrapped UintFlag.Apply -func (f *UintFlag) Apply(set *flag.FlagSet) { - f.set = set - f.UintFlag.Apply(set) -} - -// ApplyWithError saves the flagSet for later usage calls, then calls the -// wrapped UintFlag.ApplyWithError -func (f *UintFlag) ApplyWithError(set *flag.FlagSet) error { +// Apply saves the flagSet for later usage calls, then calls +// the wrapped UintFlag.Apply +func (f *UintFlag) Apply(set *flag.FlagSet) error { f.set = set - return f.UintFlag.ApplyWithError(set) + return f.UintFlag.Apply(set) } diff --git a/altsrc/flag_test.go b/altsrc/flag_test.go index 087e607..b5fcbf5 100644 --- a/altsrc/flag_test.go +++ b/altsrc/flag_test.go @@ -3,13 +3,12 @@ package altsrc import ( "flag" "fmt" + "github.com/urfave/cli/v2" "os" "runtime" "strings" "testing" "time" - - "gopkg.in/urfave/cli.v2" ) type testApplyInputSource struct { @@ -252,30 +251,30 @@ func TestDurationApplyInputSourceMethodSet(t *testing.T) { c := runTest(t, testApplyInputSource{ Flag: NewDurationFlag(&cli.DurationFlag{Name: "test"}), FlagName: "test", - MapValue: time.Duration(30 * time.Second), + MapValue: 30 * time.Second, }) - expect(t, time.Duration(30*time.Second), c.Duration("test")) + expect(t, 30*time.Second, c.Duration("test")) } func TestDurationApplyInputSourceMethodContextSet(t *testing.T) { c := runTest(t, testApplyInputSource{ Flag: NewDurationFlag(&cli.DurationFlag{Name: "test"}), FlagName: "test", - MapValue: time.Duration(30 * time.Second), - ContextValueString: time.Duration(15 * time.Second).String(), + MapValue: 30 * time.Second, + ContextValueString: (15 * time.Second).String(), }) - expect(t, time.Duration(15*time.Second), c.Duration("test")) + expect(t, 15*time.Second, c.Duration("test")) } func TestDurationApplyInputSourceMethodEnvVarSet(t *testing.T) { c := runTest(t, testApplyInputSource{ Flag: NewDurationFlag(&cli.DurationFlag{Name: "test", EnvVars: []string{"TEST"}}), FlagName: "test", - MapValue: time.Duration(30 * time.Second), + MapValue: 30 * time.Second, EnvVarName: "TEST", - EnvVarValue: time.Duration(15 * time.Second).String(), + EnvVarValue: (15 * time.Second).String(), }) - expect(t, time.Duration(15*time.Second), c.Duration("test")) + expect(t, 15*time.Second, c.Duration("test")) } func TestFloat64ApplyInputSourceMethodSet(t *testing.T) { @@ -316,19 +315,19 @@ func runTest(t *testing.T, test testApplyInputSource) *cli.Context { set := flag.NewFlagSet(test.FlagSetName, flag.ContinueOnError) c := cli.NewContext(nil, set, nil) if test.EnvVarName != "" && test.EnvVarValue != "" { - os.Setenv(test.EnvVarName, test.EnvVarValue) + _ = os.Setenv(test.EnvVarName, test.EnvVarValue) defer os.Setenv(test.EnvVarName, "") } test.Flag.Apply(set) if test.ContextValue != nil { - flag := set.Lookup(test.FlagName) - flag.Value = test.ContextValue + f := set.Lookup(test.FlagName) + f.Value = test.ContextValue } if test.ContextValueString != "" { - set.Set(test.FlagName, test.ContextValueString) + _ = set.Set(test.FlagName, test.ContextValueString) } - test.Flag.ApplyInputSourceValue(c, inputSource) + _ = test.Flag.ApplyInputSourceValue(c, inputSource) return c } diff --git a/altsrc/input_source_context.go b/altsrc/input_source_context.go index bb0afdb..5f60574 100644 --- a/altsrc/input_source_context.go +++ b/altsrc/input_source_context.go @@ -1,9 +1,8 @@ package altsrc import ( + "github.com/urfave/cli/v2" "time" - - "gopkg.in/urfave/cli.v2" ) // InputSourceContext is an interface used to allow diff --git a/altsrc/json_command_test.go b/altsrc/json_command_test.go index ccb5041..bd8e6cf 100644 --- a/altsrc/json_command_test.go +++ b/altsrc/json_command_test.go @@ -2,11 +2,10 @@ package altsrc import ( "flag" + "github.com/urfave/cli/v2" "io/ioutil" "os" "testing" - - "gopkg.in/urfave/cli.v2" ) const ( @@ -22,7 +21,7 @@ func TestCommandJSONFileTest(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) test := []string{"test-cmd", "--load", fileName} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -52,11 +51,11 @@ func TestCommandJSONFileTestGlobalEnvVarWins(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - os.Setenv("THE_TEST", "10") + _ = os.Setenv("THE_TEST", "10") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", fileName} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -87,11 +86,11 @@ func TestCommandJSONFileTestGlobalEnvVarWinsNested(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - os.Setenv("THE_TEST", "10") + _ = os.Setenv("THE_TEST", "10") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", fileName} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -123,7 +122,7 @@ func TestCommandJSONFileTestSpecifiedFlagWins(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) test := []string{"test-cmd", "--load", fileName, "--test", "7"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -155,7 +154,7 @@ func TestCommandJSONFileTestSpecifiedFlagWinsNested(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) test := []string{"test-cmd", "--load", fileName, "--top.test", "7"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -187,7 +186,7 @@ func TestCommandJSONFileTestDefaultValueFileWins(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) test := []string{"test-cmd", "--load", fileName} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -219,7 +218,7 @@ func TestCommandJSONFileTestDefaultValueFileWinsNested(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) test := []string{"test-cmd", "--load", fileName} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -250,11 +249,11 @@ func TestCommandJSONFileFlagHasDefaultGlobalEnvJSONSetGlobalEnvWins(t *testing.T app := &cli.App{} set := flag.NewFlagSet("test", 0) - os.Setenv("THE_TEST", "11") + _ = os.Setenv("THE_TEST", "11") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", fileName} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -284,11 +283,11 @@ func TestCommandJSONFileFlagHasDefaultGlobalEnvJSONSetGlobalEnvWinsNested(t *tes app := &cli.App{} set := flag.NewFlagSet("test", 0) - os.Setenv("THE_TEST", "11") + _ = os.Setenv("THE_TEST", "11") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", fileName} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) diff --git a/altsrc/json_source_context.go b/altsrc/json_source_context.go index 34c7eb9..41602ad 100644 --- a/altsrc/json_source_context.go +++ b/altsrc/json_source_context.go @@ -3,12 +3,11 @@ package altsrc import ( "encoding/json" "fmt" + "github.com/urfave/cli/v2" "io" "io/ioutil" "strings" "time" - - "gopkg.in/urfave/cli.v2" ) // NewJSONSourceFromFlagFunc returns a func that takes a cli.Context @@ -29,13 +28,8 @@ func NewJSONSourceFromFile(f string) (InputSourceContext, error) { if err != nil { return nil, err } - s, err := newJSONSource(data) - if err != nil { - return nil, err - } - s.file = f - return s, nil + return NewJSONSource(data) } // NewJSONSourceFromReader returns an InputSourceContext suitable for @@ -51,10 +45,6 @@ func NewJSONSourceFromReader(r io.Reader) (InputSourceContext, error) { // NewJSONSource returns an InputSourceContext suitable for retrieving // config variables from raw JSON data. func NewJSONSource(data []byte) (InputSourceContext, error) { - return newJSONSource(data) -} - -func newJSONSource(data []byte) (*jsonSource, error) { var deserialized map[string]interface{} if err := json.Unmarshal(data, &deserialized); err != nil { return nil, err @@ -77,9 +67,9 @@ func (x *jsonSource) Int(name string) (int, error) { case int: return v, nil case float64: - return int(float64(v)), nil + return int(v), nil case float32: - return int(float32(v)), nil + return int(v), nil } } diff --git a/altsrc/map_input_source.go b/altsrc/map_input_source.go index 41221b1..66bd6e8 100644 --- a/altsrc/map_input_source.go +++ b/altsrc/map_input_source.go @@ -2,11 +2,10 @@ package altsrc import ( "fmt" + "github.com/urfave/cli/v2" "reflect" "strings" "time" - - "gopkg.in/urfave/cli.v2" ) // MapInputSource implements InputSourceContext to return @@ -23,15 +22,15 @@ func nestedVal(name string, tree map[interface{}]interface{}) (interface{}, bool if sections := strings.Split(name, "."); len(sections) > 1 { node := tree for _, section := range sections[:len(sections)-1] { - if child, ok := node[section]; !ok { + child, ok := node[section] + if !ok { + return nil, false + } + ctype, ok := child.(map[interface{}]interface{}) + if !ok { return nil, false - } else { - if ctype, ok := child.(map[interface{}]interface{}); !ok { - return nil, false - } else { - node = ctype - } } + node = ctype } if val, ok := node[sections[len(sections)-1]]; ok { return val, true diff --git a/altsrc/toml_command_test.go b/altsrc/toml_command_test.go index 2f28d22..84558aa 100644 --- a/altsrc/toml_command_test.go +++ b/altsrc/toml_command_test.go @@ -7,20 +7,19 @@ package altsrc import ( "flag" + "github.com/urfave/cli/v2" "io/ioutil" "os" "testing" - - "gopkg.in/urfave/cli.v2" ) func TestCommandTomFileTest(t *testing.T) { - app := (&cli.App{}) + app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) + _ = ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) defer os.Remove("current.toml") test := []string{"test-cmd", "--load", "current.toml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -45,15 +44,15 @@ func TestCommandTomFileTest(t *testing.T) { } func TestCommandTomlFileTestGlobalEnvVarWins(t *testing.T) { - app := (&cli.App{}) + app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) + _ = ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) defer os.Remove("current.toml") - os.Setenv("THE_TEST", "10") + _ = os.Setenv("THE_TEST", "10") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", "current.toml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -79,15 +78,15 @@ func TestCommandTomlFileTestGlobalEnvVarWins(t *testing.T) { } func TestCommandTomlFileTestGlobalEnvVarWinsNested(t *testing.T) { - app := (&cli.App{}) + app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666) + _ = ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666) defer os.Remove("current.toml") - os.Setenv("THE_TEST", "10") + _ = os.Setenv("THE_TEST", "10") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", "current.toml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -113,13 +112,13 @@ func TestCommandTomlFileTestGlobalEnvVarWinsNested(t *testing.T) { } func TestCommandTomlFileTestSpecifiedFlagWins(t *testing.T) { - app := (&cli.App{}) + app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) + _ = ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) defer os.Remove("current.toml") test := []string{"test-cmd", "--load", "current.toml", "--test", "7"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -145,14 +144,14 @@ func TestCommandTomlFileTestSpecifiedFlagWins(t *testing.T) { } func TestCommandTomlFileTestSpecifiedFlagWinsNested(t *testing.T) { - app := (&cli.App{}) + app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte(`[top] + _ = ioutil.WriteFile("current.toml", []byte(`[top] test = 15`), 0666) defer os.Remove("current.toml") test := []string{"test-cmd", "--load", "current.toml", "--top.test", "7"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -178,13 +177,13 @@ func TestCommandTomlFileTestSpecifiedFlagWinsNested(t *testing.T) { } func TestCommandTomlFileTestDefaultValueFileWins(t *testing.T) { - app := (&cli.App{}) + app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) + _ = ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) defer os.Remove("current.toml") test := []string{"test-cmd", "--load", "current.toml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -210,13 +209,13 @@ func TestCommandTomlFileTestDefaultValueFileWins(t *testing.T) { } func TestCommandTomlFileTestDefaultValueFileWinsNested(t *testing.T) { - app := (&cli.App{}) + app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666) + _ = ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666) defer os.Remove("current.toml") test := []string{"test-cmd", "--load", "current.toml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -244,14 +243,14 @@ func TestCommandTomlFileTestDefaultValueFileWinsNested(t *testing.T) { func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWins(t *testing.T) { app := (&cli.App{}) set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) + _ = ioutil.WriteFile("current.toml", []byte("test = 15"), 0666) defer os.Remove("current.toml") - os.Setenv("THE_TEST", "11") + _ = os.Setenv("THE_TEST", "11") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", "current.toml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -276,16 +275,16 @@ func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWins(t *testing.T } func TestCommandTomlFileFlagHasDefaultGlobalEnvTomlSetGlobalEnvWinsNested(t *testing.T) { - app := (&cli.App{}) + app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666) + _ = ioutil.WriteFile("current.toml", []byte("[top]\ntest = 15"), 0666) defer os.Remove("current.toml") - os.Setenv("THE_TEST", "11") + _ = os.Setenv("THE_TEST", "11") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", "current.toml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) diff --git a/altsrc/toml_file_loader.go b/altsrc/toml_file_loader.go index 1cb2d7b..3f410fc 100644 --- a/altsrc/toml_file_loader.go +++ b/altsrc/toml_file_loader.go @@ -10,7 +10,7 @@ import ( "reflect" "github.com/BurntSushi/toml" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) type tomlMap struct { @@ -28,7 +28,7 @@ func unmarshalMap(i interface{}) (ret map[interface{}]interface{}, err error) { case reflect.String: ret[key] = val.(string) case reflect.Int: - ret[key] = int(val.(int)) + ret[key] = val.(int) case reflect.Int8: ret[key] = int(val.(int8)) case reflect.Int16: @@ -50,7 +50,7 @@ func unmarshalMap(i interface{}) (ret map[interface{}]interface{}, err error) { case reflect.Float32: ret[key] = float64(val.(float32)) case reflect.Float64: - ret[key] = float64(val.(float64)) + ret[key] = val.(float64) case reflect.Map: if tmp, err := unmarshalMap(val); err == nil { ret[key] = tmp @@ -66,9 +66,9 @@ func unmarshalMap(i interface{}) (ret map[interface{}]interface{}, err error) { return ret, nil } -func (self *tomlMap) UnmarshalTOML(i interface{}) error { +func (tm *tomlMap) UnmarshalTOML(i interface{}) error { if tmp, err := unmarshalMap(i); err == nil { - self.Map = tmp + tm.Map = tmp } else { return err } diff --git a/altsrc/yaml_command_test.go b/altsrc/yaml_command_test.go index 5290e84..2190c2b 100644 --- a/altsrc/yaml_command_test.go +++ b/altsrc/yaml_command_test.go @@ -10,17 +10,16 @@ import ( "io/ioutil" "os" "testing" - - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" ) func TestCommandYamlFileTest(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) + _ = ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) defer os.Remove("current.yaml") test := []string{"test-cmd", "--load", "current.yaml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -47,13 +46,13 @@ func TestCommandYamlFileTest(t *testing.T) { func TestCommandYamlFileTestGlobalEnvVarWins(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) + _ = ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) defer os.Remove("current.yaml") - os.Setenv("THE_TEST", "10") + _ = os.Setenv("THE_TEST", "10") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", "current.yaml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -81,14 +80,14 @@ func TestCommandYamlFileTestGlobalEnvVarWins(t *testing.T) { func TestCommandYamlFileTestGlobalEnvVarWinsNested(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte(`top: + _ = ioutil.WriteFile("current.yaml", []byte(`top: test: 15`), 0666) defer os.Remove("current.yaml") - os.Setenv("THE_TEST", "10") + _ = os.Setenv("THE_TEST", "10") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", "current.yaml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -116,11 +115,11 @@ func TestCommandYamlFileTestGlobalEnvVarWinsNested(t *testing.T) { func TestCommandYamlFileTestSpecifiedFlagWins(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) + _ = ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) defer os.Remove("current.yaml") test := []string{"test-cmd", "--load", "current.yaml", "--test", "7"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -148,12 +147,12 @@ func TestCommandYamlFileTestSpecifiedFlagWins(t *testing.T) { func TestCommandYamlFileTestSpecifiedFlagWinsNested(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte(`top: + _ = ioutil.WriteFile("current.yaml", []byte(`top: test: 15`), 0666) defer os.Remove("current.yaml") test := []string{"test-cmd", "--load", "current.yaml", "--top.test", "7"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -181,11 +180,11 @@ func TestCommandYamlFileTestSpecifiedFlagWinsNested(t *testing.T) { func TestCommandYamlFileTestDefaultValueFileWins(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) + _ = ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) defer os.Remove("current.yaml") test := []string{"test-cmd", "--load", "current.yaml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -213,12 +212,12 @@ func TestCommandYamlFileTestDefaultValueFileWins(t *testing.T) { func TestCommandYamlFileTestDefaultValueFileWinsNested(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte(`top: + _ = ioutil.WriteFile("current.yaml", []byte(`top: test: 15`), 0666) defer os.Remove("current.yaml") test := []string{"test-cmd", "--load", "current.yaml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -246,14 +245,14 @@ func TestCommandYamlFileTestDefaultValueFileWinsNested(t *testing.T) { func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWins(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) + _ = ioutil.WriteFile("current.yaml", []byte("test: 15"), 0666) defer os.Remove("current.yaml") - os.Setenv("THE_TEST", "11") + _ = os.Setenv("THE_TEST", "11") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", "current.yaml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) @@ -280,15 +279,15 @@ func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWins(t *testing.T func TestCommandYamlFileFlagHasDefaultGlobalEnvYamlSetGlobalEnvWinsNested(t *testing.T) { app := &cli.App{} set := flag.NewFlagSet("test", 0) - ioutil.WriteFile("current.yaml", []byte(`top: + _ = ioutil.WriteFile("current.yaml", []byte(`top: test: 15`), 0666) defer os.Remove("current.yaml") - os.Setenv("THE_TEST", "11") + _ = os.Setenv("THE_TEST", "11") defer os.Setenv("THE_TEST", "") test := []string{"test-cmd", "--load", "current.yaml"} - set.Parse(test) + _ = set.Parse(test) c := cli.NewContext(app, set, nil) diff --git a/altsrc/yaml_file_loader.go b/altsrc/yaml_file_loader.go index 37c8d9c..9b1dc05 100644 --- a/altsrc/yaml_file_loader.go +++ b/altsrc/yaml_file_loader.go @@ -14,7 +14,7 @@ import ( "runtime" "strings" - "gopkg.in/urfave/cli.v2" + "github.com/urfave/cli/v2" "gopkg.in/yaml.v2" ) @@ -86,7 +86,7 @@ func loadDataFrom(filePath string) ([]byte, error) { return nil, fmt.Errorf("Cannot read from file: '%s' because it does not exist.", filePath) } return ioutil.ReadFile(filePath) - } else { - return nil, fmt.Errorf("unable to determine how to load from path %s", filePath) } + + return nil, fmt.Errorf("unable to determine how to load from path %s", filePath) } diff --git a/app.go b/app.go index 4c073c5..229254b 100644 --- a/app.go +++ b/app.go @@ -1,9 +1,9 @@ package cli import ( + "flag" "fmt" "io" - "io/ioutil" "os" "path/filepath" "reflect" @@ -11,7 +11,21 @@ import ( "time" ) -// App is the main structure of a cli application. +var ( + changeLogURL = "https://github.com/urfave/cli/blob/master/CHANGELOG.md" + appActionDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-action-signature", changeLogURL) + // unused variable. commented for now. will remove in future if agreed upon by everyone + //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 @@ -31,8 +45,8 @@ type App struct { Commands []*Command // List of flags to parse Flags []Flag - // Boolean to enable shell completion commands - EnableShellCompletion bool + // 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 @@ -40,7 +54,7 @@ type App struct { // Categories contains the categorized commands and is populated on app startup Categories CommandCategories // An action to execute when the shell completion flag is set - ShellComplete ShellCompleteFunc + 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 @@ -63,6 +77,9 @@ type App struct { 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. @@ -71,6 +88,10 @@ type App struct { // cli.go uses text/template to render templates. You can // render custom help text by setting this variable. CustomAppHelpTemplate string + // 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 didSetup bool } @@ -85,6 +106,22 @@ func compileTime() time.Time { 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. @@ -111,8 +148,8 @@ func (a *App) Setup() { a.Version = "0.0.0" } - if a.ShellComplete == nil { - a.ShellComplete = DefaultAppComplete + if a.BashComplete == nil { + a.BashComplete = DefaultAppComplete } if a.Action == nil { @@ -127,14 +164,15 @@ func (a *App) Setup() { a.Writer = os.Stdout } - newCmds := []*Command{} + var newCommands []*Command + for _, c := range a.Commands { if c.HelpName == "" { c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name) } - newCmds = append(newCmds, c) + newCommands = append(newCommands, c) } - a.Commands = newCmds + a.Commands = newCommands if a.Command(helpCommand.Name) == nil && !a.HideHelp { a.appendCommand(helpCommand) @@ -144,10 +182,10 @@ func (a *App) Setup() { } } - if a.EnableShellCompletion { - a.appendFlag(GenerateCompletionFlag) - a.appendFlag(InitCompletionFlag) - } + //if a.EnableShellCompletion { + // a.appendFlag(GenerateCompletionFlag) + // a.appendFlag(InitCompletionFlag) + //} if !a.HideVersion { a.appendFlag(VersionFlag) @@ -168,6 +206,14 @@ func (a *App) Setup() { } } +func (a *App) newFlagSet() (*flag.FlagSet, error) { + return flagSet(a.Name, a.Flags) +} + +func (a *App) useShortOptionHandling() bool { + return a.UseShortOptionHandling +} + // 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) { @@ -181,19 +227,17 @@ func (a *App) Run(arguments []string) (err error) { // 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) + _, err = a.newFlagSet() if err != nil { return err } - set.SetOutput(ioutil.Discard) - err = set.Parse(arguments[1:]) + set, err := parseIter(a, arguments[1:]) nerr := normalizeFlags(a.Flags, set) context := NewContext(a, set, nil) if nerr != nil { - fmt.Fprintln(a.Writer, nerr) - ShowAppHelp(context) + _, _ = fmt.Fprintln(a.Writer, nerr) + _ = ShowAppHelp(context) return nerr } context.shellComplete = shellComplete @@ -212,17 +256,22 @@ func (a *App) Run(arguments []string) (err error) { if err != nil { if a.OnUsageError != nil { + //<<<<<<< HEAD err = a.OnUsageError(context, err, false) HandleExitCoder(err) + //======= + // err := a.OnUsageError(context, err, false) + // a.handleExitCoder(context, err) + //>>>>>>> master return err } - fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error()) - ShowAppHelp(context) + _, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error()) + _ = ShowAppHelp(context) return err } if !a.HideHelp && checkHelp(context) { - ShowAppHelp(context) + _ = ShowAppHelp(context) return nil } @@ -231,6 +280,12 @@ func (a *App) Run(arguments []string) (err error) { return nil } + cerr := checkRequiredFlags(a.Flags, context) + if cerr != nil { + _ = ShowAppHelp(context) + return cerr + } + if a.After != nil { defer func() { if afterErr := a.After(context); afterErr != nil { @@ -246,8 +301,9 @@ func (a *App) Run(arguments []string) (err error) { if a.Before != nil { beforeErr := a.Before(context) if beforeErr != nil { - ShowAppHelp(context) - HandleExitCoder(beforeErr) + _, _ = fmt.Fprintf(a.Writer, "%v\n\n", beforeErr) + _ = ShowAppHelp(context) + a.handleExitCoder(context, beforeErr) err = beforeErr return err } @@ -269,10 +325,22 @@ func (a *App) Run(arguments []string) (err error) { // Run default Action err = a.Action(context) - HandleExitCoder(err) + 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) { @@ -298,29 +366,32 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) { } a.Commands = newCmds - // append flags - if a.EnableShellCompletion { - a.appendFlag(GenerateCompletionFlag) - } - - // parse flags - set, err := flagSet(a.Name, a.Flags) + //<<<<<<< HEAD + // // append flags + // if a.EnableShellCompletion { + // a.appendFlag(GenerateCompletionFlag) + // } + // + // // parse flags + // set, err := flagSet(a.Name, a.Flags) + //======= + _, err = a.newFlagSet() + //>>>>>>> master if err != nil { return err } - set.SetOutput(ioutil.Discard) - err = set.Parse(ctx.Args().Tail()) + set, err := parseIter(a, 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) + _, _ = fmt.Fprintln(a.Writer, nerr) + _, _ = fmt.Fprintln(a.Writer) if len(a.Commands) > 0 { - ShowSubcommandHelp(context) + _ = ShowSubcommandHelp(context) } else { - ShowCommandHelp(ctx, context.Args().First()) + _ = ShowCommandHelp(ctx, context.Args().First()) } return nerr } @@ -332,11 +403,11 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) { if err != nil { if a.OnUsageError != nil { err = a.OnUsageError(context, err, true) - HandleExitCoder(err) + a.handleExitCoder(context, err) return err } - fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error()) - ShowSubcommandHelp(context) + _, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error()) + _ = ShowSubcommandHelp(context) return err } @@ -350,11 +421,17 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) { } } + cerr := checkRequiredFlags(a.Flags, context) + if cerr != nil { + _ = ShowSubcommandHelp(context) + return cerr + } + if a.After != nil { defer func() { afterErr := a.After(context) if afterErr != nil { - HandleExitCoder(err) + a.handleExitCoder(context, err) if err != nil { err = newMultiError(err, afterErr) } else { @@ -367,7 +444,7 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) { if a.Before != nil { beforeErr := a.Before(context) if beforeErr != nil { - HandleExitCoder(beforeErr) + a.handleExitCoder(context, beforeErr) err = beforeErr return err } @@ -385,7 +462,7 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) { // Run default Action err = a.Action(context) - HandleExitCoder(err) + a.handleExitCoder(context, err) return err } @@ -419,7 +496,7 @@ func (a *App) VisibleCategories() []CommandCategory { // VisibleCommands returns a slice of the Commands with Hidden=false func (a *App) VisibleCommands() []*Command { - ret := []*Command{} + var ret []*Command for _, command := range a.Commands { if !command.Hidden { ret = append(ret, command) @@ -444,7 +521,6 @@ func (a *App) hasFlag(flag Flag) bool { } func (a *App) errWriter() io.Writer { - // When the app ErrWriter is nil use the package level one. if a.ErrWriter == nil { return ErrWriter @@ -465,6 +541,14 @@ func (a *App) appendCommand(c *Command) { } } +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 @@ -488,3 +572,20 @@ func DefaultCommand(name string) ActionFunc { return ctx.App.Command(name).Run(ctx) } } + +// 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) { + switch a := action.(type) { + case ActionFunc: + return a(context) + case func(*Context) error: + return a(context) + case func(*Context): // deprecated function signature + a(context) + return nil + } + + return errInvalidActionType +} diff --git a/app_test.go b/app_test.go index 84631fd..e4bbbcb 100644 --- a/app_test.go +++ b/app_test.go @@ -86,7 +86,7 @@ func ExampleApp_Run_subcommand() { }, } - app.Run(os.Args) + _ = app.Run(os.Args) // Output: // Hello, Jeremy } @@ -119,7 +119,7 @@ func ExampleApp_Run_appHelp() { }, }, } - app.Run(os.Args) + _ = app.Run(os.Args) // Output: // NAME: // greet - A new cli application @@ -138,8 +138,8 @@ func ExampleApp_Run_appHelp() { // Oliver Allen // // COMMANDS: - // describeit, d use it to see a description - // help, h Shows a list of commands or help for one command + // describeit, d use it to see a description + // help, h Shows a list of commands or help for one command // // GLOBAL OPTIONS: // --name value a name to say (default: "bob") @@ -169,7 +169,7 @@ func ExampleApp_Run_commandHelp() { }, }, } - app.Run(os.Args) + _ = app.Run(os.Args) // Output: // NAME: // greet describeit - use it to see a description @@ -184,7 +184,7 @@ func ExampleApp_Run_commandHelp() { func ExampleApp_Run_noAction() { app := App{} app.Name = "greet" - app.Run([]string{"greet"}) + _ = app.Run([]string{"greet"}) // Output: // NAME: // greet - A new cli application @@ -196,7 +196,7 @@ func ExampleApp_Run_noAction() { // 0.0.0 // // COMMANDS: - // help, h Shows a list of commands or help for one command + // help, h Shows a list of commands or help for one command // // GLOBAL OPTIONS: // --help, -h show help (default: false) @@ -215,7 +215,7 @@ func ExampleApp_Run_subcommandNoAction() { }, }, } - app.Run([]string{"greet", "describeit"}) + _ = app.Run([]string{"greet", "describeit"}) // Output: // NAME: // greet describeit - use it to see a description @@ -231,13 +231,103 @@ func ExampleApp_Run_subcommandNoAction() { } -func ExampleApp_Run_shellComplete() { +func ExampleApp_Run_bashComplete_withShortFlag() { + os.Args = []string{"greet", "-", "--generate-bash-completion"} + + app := NewApp() + app.Name = "greet" + app.EnableBashCompletion = true + app.Flags = []Flag{ + &IntFlag{ + Name: "other", + Aliases: []string{"o"}, + }, + &StringFlag{ + Name: "xyz", + Aliases: []string{"x"}, + }, + } + + _ = app.Run(os.Args) + // Output: + // --other + // -o + // --xyz + // -x + // --help + // -h + // --version + // -v +} + +func ExampleApp_Run_bashComplete_withLongFlag() { + os.Args = []string{"greet", "--s", "--generate-bash-completion"} + + app := NewApp() + app.Name = "greet" + app.EnableBashCompletion = true + app.Flags = []Flag{ + &IntFlag{ + Name: "other", + Aliases: []string{"o"}, + }, + &StringFlag{ + Name: "xyz", + Aliases: []string{"x"}, + }, + &StringFlag{ + Name: "some-flag,s", + }, + &StringFlag{ + Name: "similar-flag", + }, + } + + _ = app.Run(os.Args) + // Output: + // --some-flag + // --similar-flag +} +func ExampleApp_Run_bashComplete_withMultipleLongFlag() { + os.Args = []string{"greet", "--st", "--generate-bash-completion"} + + app := NewApp() + app.Name = "greet" + app.EnableBashCompletion = true + app.Flags = []Flag{ + &IntFlag{ + Name: "int-flag", + Aliases: []string{"i"}, + }, + &StringFlag{ + Name: "string", + Aliases: []string{"s"}, + }, + &StringFlag{ + Name: "string-flag-2", + }, + &StringFlag{ + Name: "similar-flag", + }, + &StringFlag{ + Name: "some-flag", + }, + } + + _ = app.Run(os.Args) + // Output: + // --string + // --string-flag-2 +} + +func ExampleApp_Run_bashComplete() { + // set args for examples sake // set args for examples sake - os.Args = []string{"greet", fmt.Sprintf("--%s", genCompName())} + os.Args = []string{"greet", "--generate-bash-completion"} app := &App{ Name: "greet", - EnableShellCompletion: true, + EnableBashCompletion: true, Commands: []*Command{ { Name: "describeit", @@ -260,7 +350,7 @@ func ExampleApp_Run_shellComplete() { }, } - app.Run(os.Args) + _ = app.Run(os.Args) // Output: // describeit // d @@ -269,6 +359,44 @@ func ExampleApp_Run_shellComplete() { // h } +func ExampleApp_Run_zshComplete() { + // set args for examples sake + os.Args = []string{"greet", "--generate-bash-completion"} + _ = os.Setenv("_CLI_ZSH_AUTOCOMPLETE_HACK", "1") + + app := NewApp() + app.Name = "greet" + app.EnableBashCompletion = true + app.Commands = []*Command{ + { + Name: "describeit", + Aliases: []string{"d"}, + Usage: "use it to see a description", + Description: "This is how we describe describeit the function", + Action: func(c *Context) error { + fmt.Printf("i like to describe things") + return nil + }, + }, { + Name: "next", + Usage: "next example", + Description: "more stuff to see when generating bash completion", + Action: func(c *Context) error { + fmt.Printf("the next example") + return nil + }, + }, + } + + _ = app.Run(os.Args) + // Output: + // describeit:use it to see a description + // d:use it to see a description + // next:next example + // help:Shows a list of commands or help for one command + // h:Shows a list of commands or help for one command +} + func TestApp_Run(t *testing.T) { s := "" @@ -317,6 +445,63 @@ func TestApp_Setup_defaultsWriter(t *testing.T) { expect(t, app.Writer, os.Stdout) } + +func TestApp_CommandWithArgBeforeFlags(t *testing.T) { + var parsedOption, firstArg string + + app := NewApp() + command := &Command{ + Name: "cmd", + Flags: []Flag{ + &StringFlag{Name: "option", Value: "", Usage: "some option"}, + }, + Action: func(c *Context) error { + parsedOption = c.String("option") + firstArg = c.Args().First() + return nil + }, + } + app.Commands = []*Command{command} + + _ = app.Run([]string{"", "cmd", "my-arg", "--option", "my-option"}) + + expect(t, parsedOption, "my-option") + expect(t, firstArg, "my-arg") +} + +func TestApp_CommandWithArgBeforeBoolFlags(t *testing.T) { + var parsedOption, parsedSecondOption, firstArg string + var parsedBool, parsedSecondBool bool + + app := NewApp() + command := &Command{ + Name: "cmd", + Flags: []Flag{ + &StringFlag{Name: "option", Value: "", Usage: "some option"}, + &StringFlag{Name: "secondOption", Value: "", Usage: "another option"}, + &BoolFlag{Name: "boolflag", Usage: "some bool"}, + &BoolFlag{Name: "b", Usage: "another bool"}, + }, + Action: func(c *Context) error { + parsedOption = c.String("option") + parsedSecondOption = c.String("secondOption") + parsedBool = c.Bool("boolflag") + parsedSecondBool = c.Bool("b") + firstArg = c.Args().First() + return nil + }, + } + app.Commands = []*Command{command} + + _ = app.Run([]string{"", "cmd", "my-arg", "--boolflag", "--option", "my-option", "-b", "--secondOption", "fancy-option"}) + + expect(t, parsedOption, "my-option") + expect(t, parsedSecondOption, "fancy-option") + expect(t, parsedBool, true) + expect(t, parsedSecondBool, true) + expect(t, firstArg, "my-arg") +} + func TestApp_RunAsSubcommandParseFlags(t *testing.T) { var context *Context @@ -339,7 +524,7 @@ func TestApp_RunAsSubcommandParseFlags(t *testing.T) { }, }, } - a.Run([]string{"", "foo", "--lang", "spanish", "abcd"}) + _ = a.Run([]string{"", "foo", "--lang", "spanish", "abcd"}) expect(t, context.Args().Get(0), "abcd") expect(t, context.String("lang"), "spanish") @@ -355,7 +540,7 @@ func TestApp_RunAsSubCommandIncorrectUsage(t *testing.T) { } set := flag.NewFlagSet("", flag.ContinueOnError) - set.Parse([]string{"", "---foo"}) + _ = set.Parse([]string{"", "---foo"}) c := &Context{flagSet: set} err := a.RunAsSubcommand(c) @@ -383,7 +568,7 @@ func TestApp_CommandWithFlagBeforeTerminator(t *testing.T) { }, } - app.Run([]string{"", "cmd", "--option", "my-option", "my-arg", "--", "--notARealFlag"}) + _ = app.Run([]string{"", "cmd", "my-arg", "--option", "my-option", "--", "--notARealFlag"}) expect(t, parsedOption, "my-option") expect(t, args.Get(0), "my-arg") @@ -406,7 +591,7 @@ func TestApp_CommandWithDash(t *testing.T) { }, } - app.Run([]string{"", "cmd", "my-arg", "-"}) + _ = app.Run([]string{"", "cmd", "my-arg", "-"}) expect(t, args.Get(0), "my-arg") expect(t, args.Get(1), "-") @@ -427,7 +612,7 @@ func TestApp_CommandWithNoFlagBeforeTerminator(t *testing.T) { }, } - app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"}) + _ = app.Run([]string{"", "cmd", "my-arg", "--", "notAFlagAtAll"}) expect(t, args.Get(0), "my-arg") expect(t, args.Get(1), "--") @@ -485,6 +670,93 @@ func TestApp_VisibleCommands(t *testing.T) { } } +func TestApp_UseShortOptionHandling(t *testing.T) { + var one, two bool + var name string + expected := "expectedName" + + app := NewApp() + app.UseShortOptionHandling = true + app.Flags = []Flag{ + &BoolFlag{Name: "one", Aliases: []string{"o"}}, + &BoolFlag{Name: "two", Aliases: []string{"t"}}, + &StringFlag{Name: "name", Aliases: []string{"n"}}, + } + app.Action = func(c *Context) error { + one = c.Bool("one") + two = c.Bool("two") + name = c.String("name") + return nil + } + + _ = app.Run([]string{"", "-on", expected}) + expect(t, one, true) + expect(t, two, false) + expect(t, name, expected) +} + +func TestApp_UseShortOptionHandlingCommand(t *testing.T) { + var one, two bool + var name string + expected := "expectedName" + + app := NewApp() + app.UseShortOptionHandling = true + command := &Command{ + Name: "cmd", + Flags: []Flag{ + &BoolFlag{Name: "one", Aliases: []string{"o"}}, + &BoolFlag{Name: "two", Aliases: []string{"t"}}, + &StringFlag{Name: "name", Aliases: []string{"n"}}, + }, + Action: func(c *Context) error { + one = c.Bool("one") + two = c.Bool("two") + name = c.String("name") + return nil + }, + } + app.Commands = []*Command{command} + + _ = app.Run([]string{"", "cmd", "-on", expected}) + expect(t, one, true) + expect(t, two, false) + expect(t, name, expected) +} + +func TestApp_UseShortOptionHandlingSubCommand(t *testing.T) { + var one, two bool + var name string + expected := "expectedName" + + app := NewApp() + app.UseShortOptionHandling = true + command := &Command{ + Name: "cmd", + } + subCommand := &Command{ + Name: "sub", + Flags: []Flag{ + &BoolFlag{Name: "one", Aliases: []string{"o"}}, + &BoolFlag{Name: "two", Aliases: []string{"t"}}, + &StringFlag{Name: "name", Aliases: []string{"n"}}, + }, + Action: func(c *Context) error { + one = c.Bool("one") + two = c.Bool("two") + name = c.String("name") + return nil + }, + } + app.Commands = []*Command{command, subCommand} + + err := app.Run([]string{"", "cmd", "sub", "-on", expected}) + expect(t, err, nil) + expect(t, one, true) + expect(t, two, false) + expect(t, name, expected) +} + func TestApp_Float64Flag(t *testing.T) { var meters float64 @@ -498,7 +770,7 @@ func TestApp_Float64Flag(t *testing.T) { }, } - app.Run([]string{"", "--height", "1.93"}) + _ = app.Run([]string{"", "--height", "1.93"}) expect(t, meters, 1.93) } @@ -528,7 +800,7 @@ func TestApp_ParseSliceFlags(t *testing.T) { var _ = parsedOption var _ = firstArg - app.Run([]string{"", "cmd", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4", "my-arg"}) + _ = app.Run([]string{"", "cmd", "my-arg", "-p", "22", "-p", "80", "-ip", "8.8.8.8", "-ip", "8.8.4.4"}) IntsEquals := func(a, b []int) bool { if len(a) != len(b) { @@ -586,7 +858,7 @@ func TestApp_ParseSliceFlagsWithMissingValue(t *testing.T) { }, } - app.Run([]string{"", "cmd", "-a", "2", "-str", "A", "my-arg"}) + _ = app.Run([]string{"", "cmd", "my-arg", "-a", "2", "-str", "A"}) var expectedIntSlice = []int{2} var expectedStringSlice = []string{"A"} @@ -818,6 +1090,145 @@ func TestAppNoHelpFlag(t *testing.T) { } } +func TestRequiredFlagAppRunBehavior(t *testing.T) { + tdata := []struct { + testCase string + appFlags []Flag + appRunInput []string + appCommands []*Command + expectedAnError bool + }{ + // assertion: empty input, when a required flag is present, errors + { + testCase: "error_case_empty_input_with_required_flag_on_app", + appRunInput: []string{"myCLI"}, + appFlags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + expectedAnError: true, + }, + { + testCase: "error_case_empty_input_with_required_flag_on_command", + appRunInput: []string{"myCLI", "myCommand"}, + appCommands: []*Command{{ + Name: "myCommand", + Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + }}, + expectedAnError: true, + }, + { + testCase: "error_case_empty_input_with_required_flag_on_subcommand", + appRunInput: []string{"myCLI", "myCommand", "mySubCommand"}, + appCommands: []*Command{{ + Name: "myCommand", + Subcommands: []*Command{{ + Name: "mySubCommand", + Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + }}, + }}, + expectedAnError: true, + }, + // assertion: inputing --help, when a required flag is present, does not error + { + testCase: "valid_case_help_input_with_required_flag_on_app", + appRunInput: []string{"myCLI", "--help"}, + appFlags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + }, + { + testCase: "valid_case_help_input_with_required_flag_on_command", + appRunInput: []string{"myCLI", "myCommand", "--help"}, + appCommands: []*Command{{ + Name: "myCommand", + Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + }}, + }, + { + testCase: "valid_case_help_input_with_required_flag_on_subcommand", + appRunInput: []string{"myCLI", "myCommand", "mySubCommand", "--help"}, + appCommands: []*Command{{ + Name: "myCommand", + Subcommands: []*Command{{ + Name: "mySubCommand", + Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + }}, + }}, + }, + // assertion: giving optional input, when a required flag is present, errors + { + testCase: "error_case_optional_input_with_required_flag_on_app", + appRunInput: []string{"myCLI", "--optional", "cats"}, + appFlags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}, &StringFlag{Name: "optional"}}, + expectedAnError: true, + }, + { + testCase: "error_case_optional_input_with_required_flag_on_command", + appRunInput: []string{"myCLI", "myCommand", "--optional", "cats"}, + appCommands: []*Command{{ + Name: "myCommand", + Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}, &StringFlag{Name: "optional"}}, + }}, + expectedAnError: true, + }, + { + testCase: "error_case_optional_input_with_required_flag_on_subcommand", + appRunInput: []string{"myCLI", "myCommand", "mySubCommand", "--optional", "cats"}, + appCommands: []*Command{{ + Name: "myCommand", + Subcommands: []*Command{{ + Name: "mySubCommand", + Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}, &StringFlag{Name: "optional"}}, + }}, + }}, + expectedAnError: true, + }, + // assertion: when a required flag is present, inputting that required flag does not error + { + testCase: "valid_case_required_flag_input_on_app", + appRunInput: []string{"myCLI", "--requiredFlag", "cats"}, + appFlags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + }, + { + testCase: "valid_case_required_flag_input_on_command", + appRunInput: []string{"myCLI", "myCommand", "--requiredFlag", "cats"}, + appCommands: []*Command{{ + Name: "myCommand", + Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + }}, + }, + { + testCase: "valid_case_required_flag_input_on_subcommand", + appRunInput: []string{"myCLI", "myCommand", "mySubCommand", "--requiredFlag", "cats"}, + appCommands: []*Command{{ + Name: "myCommand", + Subcommands: []*Command{{ + Name: "mySubCommand", + Flags: []Flag{&StringFlag{Name: "requiredFlag", Required: true}}, + }}, + }}, + }, + } + for _, test := range tdata { + t.Run(test.testCase, func(t *testing.T) { + // setup + app := NewApp() + app.Flags = test.appFlags + app.Commands = test.appCommands + + // logic under test + err := app.Run(test.appRunInput) + + // assertions + if test.expectedAnError && err == nil { + t.Errorf("expected an error, but there was none") + } + if _, ok := err.(requiredFlagsErr); test.expectedAnError && !ok { + t.Errorf("expected a requiredFlagsErr, but got: %s", err) + } + if !test.expectedAnError && err != nil { + t.Errorf("did not expected an error, but there was one: %s", err) + } + }) + } +} + func TestAppHelpPrinter(t *testing.T) { oldPrinter := HelpPrinter defer func() { @@ -830,7 +1241,7 @@ func TestAppHelpPrinter(t *testing.T) { } app := &App{} - app.Run([]string{"-h"}) + _ = app.Run([]string{"-h"}) if wasCalled == false { t.Errorf("Help printer expected to be called, but was not") @@ -876,7 +1287,7 @@ func TestApp_CommandNotFound(t *testing.T) { }, } - app.Run([]string{"command", "foo"}) + _ = app.Run([]string{"command", "foo"}) expect(t, counts.CommandNotFound, 1) expect(t, counts.SubCommand, 0) @@ -889,9 +1300,9 @@ func TestApp_OrderOfOperations(t *testing.T) { resetCounts := func() { counts = &opCounts{} } app := &App{ - EnableShellCompletion: true, - ShellComplete: func(c *Context) { - fmt.Fprintf(os.Stderr, "---> ShellComplete(%#v)\n", c) + EnableBashCompletion: true, + BashComplete: func(c *Context) { + _, _ = fmt.Fprintf(os.Stderr, "---> BashComplete(%#v)\n", c) counts.Total++ counts.ShellComplete = counts.Total }, @@ -956,7 +1367,7 @@ func TestApp_OrderOfOperations(t *testing.T) { resetCounts() - _ = app.Run([]string{"command", fmt.Sprintf("--%s", genCompName())}) + _ = app.Run([]string{"command", fmt.Sprintf("--%s", "--generate-bash-completion")}) expect(t, counts.ShellComplete, 1) expect(t, counts.Total, 1) @@ -1306,7 +1717,7 @@ func TestApp_Run_Categories(t *testing.T) { Writer: buf, } - app.Run([]string{"categories"}) + _ = app.Run([]string{"categories"}) expect := commandCategories([]*commandCategory{ { @@ -1569,6 +1980,18 @@ func (c *customBoolFlag) Names() []string { return []string{c.Nombre} } +func (c *customBoolFlag) TakesValue() bool { + return false +} + +func (c *customBoolFlag) GetValue() string { + return "value" +} + +func (c *customBoolFlag) GetUsage() string { + return "usage" +} + func (c *customBoolFlag) Apply(set *flag.FlagSet) { set.String(c.Nombre, c.Nombre, "") } @@ -1613,6 +2036,59 @@ func TestCustomHelpVersionFlags(t *testing.T) { } } +func TestHandleExitCoder_Default(t *testing.T) { + app := NewApp() + fs, err := flagSet(app.Name, app.Flags) + if err != nil { + t.Errorf("error creating FlagSet: %s", err) + } + + ctx := NewContext(app, fs, nil) + app.handleExitCoder(ctx, NewExitError("Default Behavior Error", 42)) + + output := fakeErrWriter.String() + if !strings.Contains(output, "Default") { + t.Fatalf("Expected Default Behavior from Error Handler but got: %s", output) + } +} + +func TestHandleExitCoder_Custom(t *testing.T) { + app := NewApp() + fs, err := flagSet(app.Name, app.Flags) + if err != nil { + t.Errorf("error creating FlagSet: %s", err) + } + + app.ExitErrHandler = func(_ *Context, _ error) { + _, _ = fmt.Fprintln(ErrWriter, "I'm a Custom error handler, I print what I want!") + } + + ctx := NewContext(app, fs, nil) + app.handleExitCoder(ctx, NewExitError("Default Behavior Error", 42)) + + output := fakeErrWriter.String() + if !strings.Contains(output, "Custom") { + t.Fatalf("Expected Custom Behavior from Error Handler but got: %s", output) + } +} + +func TestHandleAction_WithUnknownPanic(t *testing.T) { + defer func() { refute(t, recover(), nil) }() + + var fn ActionFunc + + app := NewApp() + app.Action = func(ctx *Context) error { + _ = fn(ctx) + return nil + } + fs, err := flagSet(app.Name, app.Flags) + if err != nil { + t.Errorf("error creating FlagSet: %s", err) + } + _ = HandleAction(app.Action, NewContext(app, fs, nil)) +} + func TestShellCompletionForIncompleteFlags(t *testing.T) { app := &App{ Flags: []Flag{ @@ -1620,30 +2096,30 @@ func TestShellCompletionForIncompleteFlags(t *testing.T) { Name: "test-completion", }, }, - EnableShellCompletion: true, - ShellComplete: func(ctx *Context) { + EnableBashCompletion: true, + BashComplete: func(ctx *Context) { for _, command := range ctx.App.Commands { if command.Hidden { continue } for _, name := range command.Names() { - fmt.Fprintln(ctx.App.Writer, name) + _, _ = fmt.Fprintln(ctx.App.Writer, name) } } for _, flag := range ctx.App.Flags { for _, name := range flag.Names() { - if name == genCompName() { + if name == BashCompletionFlag.Names()[0] { continue } switch name = strings.TrimSpace(name); len(name) { case 0: case 1: - fmt.Fprintln(ctx.App.Writer, "-"+name) + _, _ = fmt.Fprintln(ctx.App.Writer, "-"+name) default: - fmt.Fprintln(ctx.App.Writer, "--"+name) + _, _ = fmt.Fprintln(ctx.App.Writer, "--"+name) } } } @@ -1652,8 +2128,62 @@ func TestShellCompletionForIncompleteFlags(t *testing.T) { return fmt.Errorf("should not get here") }, } - err := app.Run([]string{"", "--test-completion", "--" + genCompName()}) + err := app.Run([]string{"", "--test-completion", "--" + "generate-bash-completion"}) if err != nil { t.Errorf("app should not return an error: %s", err) } } + +func TestWhenExitSubCommandWithCodeThenAppQuitUnexpectedly(t *testing.T) { + testCode := 104 + + app := NewApp() + app.Commands = []*Command{ + { + Name: "cmd", + Subcommands: []*Command{ + { + Name: "subcmd", + Action: func(c *Context) error { + return NewExitError("exit error", testCode) + }, + }, + }, + }, + } + + // set user function as ExitErrHandler + var exitCodeFromExitErrHandler int + app.ExitErrHandler = func(c *Context, err error) { + if exitErr, ok := err.(ExitCoder); ok { + t.Log(exitErr) + exitCodeFromExitErrHandler = exitErr.ExitCode() + } + } + + // keep and restore original OsExiter + origExiter := OsExiter + defer func() { + OsExiter = origExiter + }() + + // set user function as OsExiter + var exitCodeFromOsExiter int + OsExiter = func(exitCode int) { + exitCodeFromOsExiter = exitCode + } + + _ = app.Run([]string{ + "myapp", + "cmd", + "subcmd", + }) + + if exitCodeFromOsExiter != 0 { + t.Errorf("exitCodeFromOsExiter should not change, but its value is %v", exitCodeFromOsExiter) + } + + if exitCodeFromExitErrHandler != testCode { + t.Errorf("exitCodeFromOsExiter valeu should be %v, but its value is %v", testCode, exitCodeFromExitErrHandler) + } +} diff --git a/appveyor.yml b/appveyor.yml index 886f0e9..a8c05a1 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -11,26 +11,17 @@ cache: environment: GOPATH: C:\gopath - GOVERSION: 1.8.x - PYTHON: C:\Python36-x64 - PYTHON_VERSION: 3.6.x - PYTHON_ARCH: 64 + GOVERSION: 1.11.x install: -- set PATH=%GOPATH%\bin;C:\go\bin;%PATH% -- go version -- go env -- go get github.com/urfave/gfmrun/... -- rmdir c:\gopath\src\gopkg.in\urfave\cli.v2 /s /q -- rmdir c:\gopath\pkg /s /q -- git clone . c:\gopath\src\gopkg.in\urfave\cli.v2 -- go get -v -t ./... -- if not exist node_modules\.bin\markdown-toc npm install markdown-toc + - 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 -- python cli-v1-to-v2 --selftest -- python runtests migrations -- python runtests toc + - go run build.go vet + - go run build.go test + - go run build.go gfmrun + diff --git a/autocomplete/bash_autocomplete b/autocomplete/bash_autocomplete index 37d9c14..f0f6241 100755 --- a/autocomplete/bash_autocomplete +++ b/autocomplete/bash_autocomplete @@ -3,14 +3,19 @@ : ${PROG:=$(basename ${BASH_SOURCE})} _cli_bash_autocomplete() { + if [[ "${COMP_WORDS[0]}" != "source" ]]; then local cur opts base COMPREPLY=() cur="${COMP_WORDS[COMP_CWORD]}" - opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion ) + if [[ "$cur" == "-"* ]]; then + opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} ${cur} --generate-bash-completion ) + else + opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion ) + fi COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) ) return 0 + fi } -complete -F _cli_bash_autocomplete $PROG - +complete -o bashdefault -o default -o nospace -F _cli_bash_autocomplete $PROG unset PROG diff --git a/autocomplete/zsh_autocomplete b/autocomplete/zsh_autocomplete index 5430a18..8b747ae 100644 --- a/autocomplete/zsh_autocomplete +++ b/autocomplete/zsh_autocomplete @@ -1,5 +1,11 @@ -autoload -U compinit && compinit -autoload -U bashcompinit && bashcompinit +_cli_zsh_autocomplete() { -script_dir=$(dirname $0) -source ${script_dir}/bash_autocomplete + local -a opts + opts=("${(@f)$(_CLI_ZSH_AUTOCOMPLETE_HACK=1 ${words[@]:0:#words[@]-1} --generate-bash-completion)}") + + _describe 'values' opts + + return +} + +compdef _cli_zsh_autocomplete $PROG diff --git a/build.go b/build.go new file mode 100644 index 0000000..a828ae4 --- /dev/null +++ b/build.go @@ -0,0 +1,164 @@ +//+build ignore + +package main + +import ( + "bufio" + "bytes" + "fmt" + "io/ioutil" + "log" + "os" + "os/exec" + "strings" + + "github.com/urfave/cli" +) + +var packages = []string{"cli", "altsrc"} + +func main() { + app := cli.NewApp() + + app.Name = "builder" + app.Usage = "Generates a new urfave/cli build!" + + app.Commands = cli.Commands{ + cli.Command{ + Name: "vet", + Action: VetActionFunc, + }, + cli.Command{ + Name: "test", + Action: TestActionFunc, + }, + cli.Command{ + Name: "gfmrun", + Action: GfmrunActionFunc, + }, + cli.Command{ + Name: "toc", + Action: TocActionFunc, + }, + } + + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + } +} + +func runCmd(arg string, args ...string) error { + cmd := exec.Command(arg, args...) + + cmd.Stdin = os.Stdin + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + + return cmd.Run() +} + +func VetActionFunc(_ *cli.Context) error { + return runCmd("go", "vet") +} + +func TestActionFunc(c *cli.Context) error { + for _, pkg := range packages { + var packageName string + + if pkg == "cli" { + packageName = "github.com/urfave/cli" + } else { + packageName = fmt.Sprintf("github.com/urfave/cli/%s", pkg) + } + + coverProfile := fmt.Sprintf("--coverprofile=%s.coverprofile", pkg) + + err := runCmd("go", "test", "-v", coverProfile, packageName) + if err != nil { + return err + } + } + + return testCleanup() +} + +func testCleanup() error { + var out bytes.Buffer + + for _, pkg := range packages { + file, err := os.Open(fmt.Sprintf("%s.coverprofile", pkg)) + if err != nil { + return err + } + + b, err := ioutil.ReadAll(file) + if err != nil { + return err + } + + out.Write(b) + err = file.Close() + if err != nil { + return err + } + + err = os.Remove(fmt.Sprintf("%s.coverprofile", pkg)) + if err != nil { + return err + } + } + + outFile, err := os.Create("coverage.txt") + if err != nil { + return err + } + + _, err = out.WriteTo(outFile) + if err != nil { + return err + } + + err = outFile.Close() + if err != nil { + return err + } + + return nil +} + +func GfmrunActionFunc(_ *cli.Context) error { + file, err := os.Open("README.md") + if err != nil { + return err + } + + var counter int + scanner := bufio.NewScanner(file) + for scanner.Scan() { + if strings.Contains(scanner.Text(), "package main") { + counter++ + } + } + + err = scanner.Err() + if err != nil { + return err + } + + return runCmd("gfmrun", "-c", fmt.Sprint(counter), "-s", "README.md") +} + +func TocActionFunc(_ *cli.Context) error { + err := runCmd("node_modules/.bin/markdown-toc", "-i", "README.md") + if err != nil { + return err + } + + err = runCmd("git", "diff", "--exit-code") + if err != nil { + return err + } + + return nil +} diff --git a/category.go b/category.go index 3b405c0..64d84ec 100644 --- a/category.go +++ b/category.go @@ -15,7 +15,7 @@ func newCommandCategories() CommandCategories { } func (c *commandCategories) Less(i, j int) bool { - return (*c)[i].Name() < (*c)[j].Name() + return lexicographicLess((*c)[i].Name(), (*c)[j].Name() ) } func (c *commandCategories) Len() int { @@ -35,7 +35,7 @@ func (c *commandCategories) AddCommand(category string, command *Command) { } newVal := commandCategories(append(*c, &commandCategory{name: category, commands: []*Command{command}})) - (*c) = newVal + *c = newVal } func (c *commandCategories) Categories() []CommandCategory { @@ -75,7 +75,7 @@ func (c *commandCategory) VisibleCommands() []*Command { c.commands = []*Command{} } - ret := []*Command{} + var ret []*Command for _, command := range c.commands { if !command.Hidden { ret = append(ret, command) diff --git a/cli.go b/cli.go index 81fc7ab..62a5bc2 100644 --- a/cli.go +++ b/cli.go @@ -20,4 +20,4 @@ // } package cli -//go:generate python ./generate-flag-types cli -i flag-types.json -o flag_generated.go +//go:generate go run flag-gen/main.go flag-gen/assets_vfsdata.go diff --git a/command.go b/command.go index 05093b8..181091e 100644 --- a/command.go +++ b/command.go @@ -1,6 +1,7 @@ package cli import ( + "flag" "fmt" "io/ioutil" "sort" @@ -23,8 +24,8 @@ type Command struct { ArgsUsage string // The category the command is part of Category string - // The function to call when checking for shell command completions - ShellComplete ShellCompleteFunc + // 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 @@ -45,6 +46,10 @@ type Command struct { 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 arguments 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 @@ -63,7 +68,7 @@ func (c CommandsByName) Len() int { } func (c CommandsByName) Less(i, j int) bool { - return c[i].Name < c[j].Name + return lexicographicLess(c[i].Name, c[j].Name) } func (c CommandsByName) Swap(i, j int) { @@ -90,10 +95,14 @@ func (c *Command) Run(ctx *Context) (err error) { c.appendFlag(HelpFlag) } - if ctx.App.EnableShellCompletion { - c.appendFlag(GenerateCompletionFlag) + if ctx.App.UseShortOptionHandling { + c.UseShortOptionHandling = true } + //if ctx.App.EnableShellCompletion { + // c.appendFlag(GenerateCompletionFlag) + //} + set, err := flagSet(c.Name, c.Flags) if err != nil { return err @@ -108,9 +117,9 @@ func (c *Command) Run(ctx *Context) (err error) { nerr := normalizeFlags(c.Flags, set) if nerr != nil { - fmt.Fprintln(ctx.App.Writer, nerr) - fmt.Fprintln(ctx.App.Writer) - ShowCommandHelp(ctx, c.Name) + _, _ = fmt.Fprintln(ctx.App.Writer, nerr) + _, _ = fmt.Fprintln(ctx.App.Writer) + _ = ShowCommandHelp(ctx, c.Name) return nerr } @@ -126,9 +135,9 @@ func (c *Command) Run(ctx *Context) (err error) { HandleExitCoder(err) return err } - fmt.Fprintln(context.App.Writer, "Incorrect Usage:", err.Error()) - fmt.Fprintln(context.App.Writer) - ShowCommandHelp(context, c.Name) + _, _ = fmt.Fprintln(context.App.Writer, "Incorrect Usage:", err.Error()) + _, _ = fmt.Fprintln(context.App.Writer) + _ = ShowCommandHelp(context, c.Name) return err } @@ -136,6 +145,12 @@ func (c *Command) Run(ctx *Context) (err error) { return nil } + cerr := checkRequiredFlags(c.Flags, context) + if cerr != nil { + _ = ShowCommandHelp(context, c.Name) + return cerr + } + if c.After != nil { defer func() { afterErr := c.After(context) @@ -172,6 +187,14 @@ func (c *Command) Run(ctx *Context) (err error) { return err } +func (c *Command) newFlagSet() (*flag.FlagSet, error) { + return flagSet(c.Name, c.Flags) +} + +func (c *Command) useShortOptionHandling() bool { + return c.UseShortOptionHandling +} + // Names returns the names including short names and aliases. func (c *Command) Names() []string { return append([]string{c.Name}, c.Aliases...) @@ -217,6 +240,7 @@ func (c *Command) startApp(ctx *Context) error { app.Compiled = ctx.App.Compiled app.Writer = ctx.App.Writer app.ErrWriter = ctx.App.ErrWriter + app.UseShortOptionHandling = ctx.App.UseShortOptionHandling app.Categories = newCommandCategories() for _, command := range c.Subcommands { @@ -226,9 +250,9 @@ func (c *Command) startApp(ctx *Context) error { sort.Sort(app.Categories.(*commandCategories)) // bash completion - app.EnableShellCompletion = ctx.App.EnableShellCompletion - if c.ShellComplete != nil { - app.ShellComplete = c.ShellComplete + app.EnableBashCompletion = ctx.App.EnableBashCompletion + if c.BashComplete != nil { + app.BashComplete = c.BashComplete } // set the actions diff --git a/command_test.go b/command_test.go index 7fb3980..f2ccf9a 100644 --- a/command_test.go +++ b/command_test.go @@ -11,32 +11,40 @@ import ( func TestCommandFlagParsing(t *testing.T) { cases := []struct { - testArgs []string - skipFlagParsing bool - expectedErr error + testArgs []string + skipFlagParsing bool + skipArgReorder bool + expectedErr error + UseShortOptionHandling bool }{ // Test normal "not ignoring flags" flow - {[]string{"test-cmd", "-break", "blah", "blah"}, false, errors.New("flag provided but not defined: -break")}, + {[]string{"test-cmd", "blah", "blah", "-break"}, false, false, errors.New("flag provided but not defined: -break"), false}, - {[]string{"test-cmd", "blah", "blah"}, true, nil}, // Test SkipFlagParsing without any args that look like flags - {[]string{"test-cmd", "blah", "-break"}, true, nil}, // Test SkipFlagParsing with random flag arg - {[]string{"test-cmd", "blah", "-help"}, true, nil}, // Test SkipFlagParsing with "special" help flag arg + // Test no arg reorder + {[]string{"test-cmd", "blah", "blah", "-break"}, false, true, nil, false}, + {[]string{"test-cmd", "blah", "blah", "-break", "ls", "-l"}, false, true, nil, true}, + + {[]string{"test-cmd", "blah", "blah"}, true, false, nil, false}, // Test SkipFlagParsing without any args that look like flags + {[]string{"test-cmd", "blah", "-break"}, true, false, nil, false}, // Test SkipFlagParsing with random flag arg + {[]string{"test-cmd", "blah", "-help"}, true, false, nil, false}, // Test SkipFlagParsing with "special" help flag arg + {[]string{"test-cmd", "blah"}, false, false, nil, true}, // Test UseShortOptionHandling } for _, c := range cases { app := &App{Writer: ioutil.Discard} set := flag.NewFlagSet("test", 0) - set.Parse(c.testArgs) + _ = set.Parse(c.testArgs) context := NewContext(app, set, nil) command := Command{ - Name: "test-cmd", - Aliases: []string{"tc"}, - Usage: "this is for testing", - Description: "testing", - Action: func(_ *Context) error { return nil }, - SkipFlagParsing: c.skipFlagParsing, + Name: "test-cmd", + Aliases: []string{"tc"}, + Usage: "this is for testing", + Description: "testing", + Action: func(_ *Context) error { return nil }, + SkipFlagParsing: c.skipFlagParsing, + UseShortOptionHandling: c.UseShortOptionHandling, } err := command.Run(context) @@ -46,6 +54,51 @@ func TestCommandFlagParsing(t *testing.T) { } } +func TestParseAndRunShortOpts(t *testing.T) { + cases := []struct { + testArgs []string + expectedErr error + expectedArgs []string + }{ + {[]string{"foo", "test", "-a"}, nil, []string{}}, + {[]string{"foo", "test", "-c", "arg1", "arg2"}, nil, []string{"arg1", "arg2"}}, + {[]string{"foo", "test", "-f"}, nil, []string{}}, + {[]string{"foo", "test", "-ac", "--fgh"}, nil, []string{}}, + {[]string{"foo", "test", "-af"}, nil, []string{}}, + {[]string{"foo", "test", "-cf"}, nil, []string{}}, + {[]string{"foo", "test", "-acf"}, nil, []string{}}, + {[]string{"foo", "test", "-invalid"}, errors.New("flag provided but not defined: -invalid"), []string{}}, + {[]string{"foo", "test", "-acf", "arg1", "-invalid"}, nil, []string{"arg1", "-invalid"}}, + } + + var args Args + cmd := Command{ + Name: "test", + Usage: "this is for testing", + Description: "testing", + Action: func(c *Context) error { + args = c.Args() + return nil + }, + UseShortOptionHandling: true, + Flags: []Flag{ + &BoolFlag{Name: "abc", Aliases: []string{"a"}}, + &BoolFlag{Name: "cde", Aliases: []string{"c"}}, + &BoolFlag{Name: "fgh", Aliases: []string{"f"}}, + }, + } + + for _, c := range cases { + app := NewApp() + app.Commands = []Command{cmd} + + err := app.Run(c.testArgs) + + expect(t, err, c.expectedErr) + expect(t, args, c.expectedArgs) + } +} + func TestCommand_Run_DoesNotOverwriteErrorFromBefore(t *testing.T) { app := &App{ Commands: []*Command{ @@ -238,3 +291,77 @@ func TestCommand_Run_SubcommandsCanUseErrWriter(t *testing.T) { t.Fatal(err) } } + +func TestCommandFlagReordering(t *testing.T) { + cases := []struct { + testArgs []string + expectedValue string + expectedArgs []string + expectedErr error + }{ + {[]string{"some-exec", "some-command", "some-arg", "--flag", "foo"}, "foo", []string{"some-arg"}, nil}, + {[]string{"some-exec", "some-command", "some-arg", "--flag=foo"}, "foo", []string{"some-arg"}, nil}, + {[]string{"some-exec", "some-command", "--flag=foo", "some-arg"}, "foo", []string{"some-arg"}, nil}, + } + + for _, c := range cases { + value := "" + var args Args + app := &App{ + Commands: []*Command{ + { + Name: "some-command", + Flags: []Flag{ + &StringFlag{Name: "flag"}, + }, + Action: func(c *Context) error { + fmt.Printf("%+v\n", c.String("flag")) + value = c.String("flag") + args = c.Args() + return nil + }, + }, + }, + } + + err := app.Run(c.testArgs) + expect(t, err, c.expectedErr) + expect(t, value, c.expectedValue) + expect(t, args, c.expectedArgs) + } +} + +func TestCommandSkipFlagParsing(t *testing.T) { + cases := []struct { + testArgs []string + expectedArgs []string + expectedErr error + }{ + {[]string{"some-exec", "some-command", "some-arg", "--flag", "foo"}, []string{"some-arg", "--flag", "foo"}, nil}, + {[]string{"some-exec", "some-command", "some-arg", "--flag=foo"}, []string{"some-arg", "--flag=foo"}, nil}, + } + + for _, c := range cases { + var args Args + app := &App{ + Commands: []*Command{ + { + SkipFlagParsing: true, + Name: "some-command", + Flags: []Flag{ + &StringFlag{Name: "flag"}, + }, + Action: func(c *Context) error { + fmt.Printf("%+v\n", c.String("flag")) + args = c.Args() + return nil + }, + }, + }, + } + + err := app.Run(c.testArgs) + expect(t, err, c.expectedErr) + expect(t, args, c.expectedArgs) + } +} diff --git a/context.go b/context.go index f1a01b4..ba477f6 100644 --- a/context.go +++ b/context.go @@ -4,6 +4,7 @@ import ( "context" "errors" "flag" + "fmt" "os" "os/signal" "reflect" @@ -20,7 +21,7 @@ type Context struct { App *App Command *Command shellComplete bool - + setFlags map[string]bool flagSet *flag.FlagSet parentContext *Context } @@ -65,41 +66,56 @@ func (c *Context) IsSet(name string) bool { isSet = true } }) - if isSet { - return true - } - } - // 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 avaliable. - // - // See https://github.com/urfave/cli/issues/294 for additional discussion - f := lookupFlag(name, c) - if f == nil { - return 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 { + for _, name := range f.Names() { + if isSet, ok := c.setFlags[name]; isSet || !ok { + continue + } - val := reflect.ValueOf(f) - if val.Kind() == reflect.Ptr { - val = val.Elem() - } + val := reflect.ValueOf(f) + if val.Kind() == reflect.Ptr { + val = val.Elem() + } - envVarValues := val.FieldByName("EnvVars") - if !envVarValues.IsValid() { - return false - } + 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 + } + }) + } - for _, envVar := range envVarValues.Interface().([]string) { - envVar = strings.TrimSpace(envVar) - if envVal := os.Getenv(envVar); envVal != "" { - return true + envVarValues := val.FieldByName("EnvVars") + if envVarValues.IsValid() { + for _, envVar := range envVarValues.Interface().([]string) { + envVar = strings.TrimSpace(envVar) + if _, ok := syscall.Getenv(envVar); ok { + c.setFlags[name] = true + continue + } + } + } + } } } @@ -108,7 +124,7 @@ func (c *Context) IsSet(name string) bool { // LocalFlagNames returns a slice of flag names used in this context. func (c *Context) LocalFlagNames() []string { - names := []string{} + var names []string c.flagSet.Visit(makeFlagNameVisitor(&names)) return names } @@ -116,17 +132,42 @@ func (c *Context) LocalFlagNames() []string { // FlagNames returns a slice of flag names used by the this context and all of // its parent contexts. func (c *Context) FlagNames() []string { - names := []string{} + var names []string for _, ctx := range c.Lineage() { ctx.flagSet.Visit(makeFlagNameVisitor(&names)) + } return names } +// FlagNames returns a slice of flag names used in this context. +//func (c *Context) FlagNames() (names []string) { +// for _, f := range c.Command.Flags { +// name := strings.Split(f.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 _, f := range c.App.Flags { +// name := strings.Split(f.GetName(), ",")[0] +// if name == "help" || name == "version" { +// continue +// } +// names = append(names, name) +// } +// return names +//} + // Lineage returns *this* context and all of its ancestor contexts in order from // child to parent func (c *Context) Lineage() []*Context { - lineage := []*Context{} + var lineage []*Context for cur := c; cur != nil; cur = cur.parentContext { lineage = append(lineage, cur) @@ -191,10 +232,10 @@ func lookupFlagSet(name string, ctx *Context) *flag.FlagSet { func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) { switch ff.Value.(type) { - case Serializeder: - set.Set(name, ff.Value.(Serializeder).Serialized()) + case Serializer: + _ = set.Set(name, ff.Value.(Serializer).Serialize()) default: - set.Set(name, ff.Value.String()) + _ = set.Set(name, ff.Value.String()) } } @@ -244,7 +285,58 @@ func makeFlagNameVisitor(names *[]string) func(*flag.Flag) { } if name != "" { - (*names) = append(*names, name) + *names = append(*names, name) } } } + +type requiredFlagsErr interface { + error + getMissingFlags() []string +} + +type errRequiredFlags struct { + missingFlags []string +} + +func (e *errRequiredFlags) Error() string { + numberOfMissingFlags := len(e.missingFlags) + if numberOfMissingFlags == 1 { + return fmt.Sprintf("Required flag %q not set", e.missingFlags[0]) + } + joinedMissingFlags := strings.Join(e.missingFlags, ", ") + return fmt.Sprintf("Required flags %q not set", joinedMissingFlags) +} + +func (e *errRequiredFlags) getMissingFlags() []string { + return e.missingFlags +} + +func checkRequiredFlags(flags []Flag, context *Context) requiredFlagsErr { + var missingFlags []string + for _, f := range flags { + if rf, ok := f.(RequiredFlag); ok && rf.IsRequired() { + var flagPresent bool + var flagName string + for _, key := range f.Names() { + if len(key) > 1 { + flagName = key + } + + if context.IsSet(strings.TrimSpace(key)) { + flagPresent = true + } + } + + if !flagPresent && flagName != "" { + missingFlags = append(missingFlags, flagName) + } + } + } + + if len(missingFlags) != 0 { + return &errRequiredFlags{missingFlags: missingFlags} + } + + return nil +} diff --git a/context_test.go b/context_test.go index 7333ae0..c15528b 100644 --- a/context_test.go +++ b/context_test.go @@ -3,7 +3,12 @@ package cli import ( "context" "flag" + "sort" + + "os" + "strings" + "testing" "time" ) @@ -91,9 +96,11 @@ func TestContext_Float64(t *testing.T) { func TestContext_Duration(t *testing.T) { set := flag.NewFlagSet("test", 0) set.Duration("myflag", 12*time.Second, "doc") + parentSet := flag.NewFlagSet("test", 0) parentSet.Duration("top-flag", 13*time.Second, "doc") parentCtx := NewContext(nil, parentSet, nil) + c := NewContext(nil, set, parentCtx) expect(t, c.Duration("myflag"), 12*time.Second) expect(t, c.Duration("top-flag"), 13*time.Second) @@ -136,7 +143,7 @@ func TestContext_Args(t *testing.T) { set := flag.NewFlagSet("test", 0) set.Bool("myflag", false, "doc") c := NewContext(nil, set, nil) - set.Parse([]string{"--myflag", "bat", "baz"}) + _ = set.Parse([]string{"--myflag", "bat", "baz"}) expect(t, c.Args().Len(), 2) expect(t, c.Bool("myflag"), true) } @@ -145,7 +152,7 @@ func TestContext_NArg(t *testing.T) { set := flag.NewFlagSet("test", 0) set.Bool("myflag", false, "doc") c := NewContext(nil, set, nil) - set.Parse([]string{"--myflag", "bat", "baz"}) + _ = set.Parse([]string{"--myflag", "bat", "baz"}) expect(t, c.NArg(), 2) } @@ -159,8 +166,8 @@ func TestContext_IsSet(t *testing.T) { parentCtx := NewContext(nil, parentSet, nil) ctx := NewContext(nil, set, parentCtx) - set.Parse([]string{"--one-flag", "--two-flag", "--three-flag", "frob"}) - parentSet.Parse([]string{"--top-flag"}) + _ = set.Parse([]string{"--one-flag", "--two-flag", "--three-flag", "frob"}) + _ = parentSet.Parse([]string{"--top-flag"}) expect(t, ctx.IsSet("one-flag"), true) expect(t, ctx.IsSet("two-flag"), true) @@ -169,6 +176,121 @@ func TestContext_IsSet(t *testing.T) { expect(t, ctx.IsSet("bogus"), false) } +// XXX Corresponds to hack in context.IsSet for flags with EnvVar field +// Should be moved to `flag_test` in v2 +func TestContext_IsSet_fromEnv(t *testing.T) { + var ( + timeoutIsSet, tIsSet bool + noEnvVarIsSet, nIsSet bool + passwordIsSet, pIsSet bool + unparsableIsSet, uIsSet bool + ) + + os.Clearenv() + _ = os.Setenv("APP_TIMEOUT_SECONDS", "15.5") + _ = os.Setenv("APP_PASSWORD", "") + a := App{ + Flags: []Flag{ + &Float64Flag{Name: "timeout", Aliases: []string{"t"}, EnvVars: []string{"APP_TIMEOUT_SECONDS"}}, + &StringFlag{Name: "password", Aliases: []string{"p"}, EnvVars: []string{"APP_PASSWORD"}}, + &Float64Flag{Name: "unparsable", Aliases: []string{"u"}, EnvVars: []string{"APP_UNPARSABLE"}}, + &Float64Flag{Name: "no-env-var", Aliases: []string{"n"}}, + }, + Action: func(ctx *Context) error { + timeoutIsSet = ctx.IsSet("timeout") + tIsSet = ctx.IsSet("t") + passwordIsSet = ctx.IsSet("password") + pIsSet = ctx.IsSet("p") + unparsableIsSet = ctx.IsSet("unparsable") + uIsSet = ctx.IsSet("u") + noEnvVarIsSet = ctx.IsSet("no-env-var") + nIsSet = ctx.IsSet("n") + return nil + }, + } + _ = a.Run([]string{"run"}) + expect(t, timeoutIsSet, true) + expect(t, tIsSet, true) + expect(t, passwordIsSet, true) + expect(t, pIsSet, true) + expect(t, noEnvVarIsSet, false) + expect(t, nIsSet, false) + + _ = os.Setenv("APP_UNPARSABLE", "foobar") + _ = a.Run([]string{"run"}) + expect(t, unparsableIsSet, false) + expect(t, uIsSet, false) +} + +// XXX Corresponds to hack in context.IsSet for flags with EnvVar field +// TODO: Should be moved to `flag_test` in v2 +//func TestContext_GlobalIsSet_fromEnv(t *testing.T) { +// var ( +// timeoutIsSet, tIsSet bool +// noEnvVarIsSet, nIsSet bool +// passwordIsSet, pIsSet bool +// passwordValue string +// unparsableIsSet, uIsSet bool +// overrideIsSet, oIsSet bool +// overrideValue string +// ) +// +// os.Clearenv() +// _ = os.Setenv("APP_TIMEOUT_SECONDS", "15.5") +// _ = os.Setenv("APP_PASSWORD", "badpass") +// _ = os.Setenv("APP_OVERRIDE", "overridden") +// a := App{ +// Flags: []Flag{ +// Float64Flag{Name: "timeout, t", EnvVar: "APP_TIMEOUT_SECONDS"}, +// StringFlag{Name: "password, p", EnvVar: "APP_PASSWORD"}, +// Float64Flag{Name: "no-env-var, n"}, +// Float64Flag{Name: "unparsable, u", EnvVar: "APP_UNPARSABLE"}, +// StringFlag{Name: "overrides-default, o", Value: "default", EnvVar: "APP_OVERRIDE"}, +// }, +// Commands: []Command{ +// { +// Name: "hello", +// Action: func(ctx *Context) error { +// timeoutIsSet = ctx.GlobalIsSet("timeout") +// tIsSet = ctx.GlobalIsSet("t") +// passwordIsSet = ctx.GlobalIsSet("password") +// pIsSet = ctx.GlobalIsSet("p") +// passwordValue = ctx.GlobalString("password") +// unparsableIsSet = ctx.GlobalIsSet("unparsable") +// uIsSet = ctx.GlobalIsSet("u") +// noEnvVarIsSet = ctx.GlobalIsSet("no-env-var") +// nIsSet = ctx.GlobalIsSet("n") +// overrideIsSet = ctx.GlobalIsSet("overrides-default") +// oIsSet = ctx.GlobalIsSet("o") +// overrideValue = ctx.GlobalString("overrides-default") +// return nil +// }, +// }, +// }, +// } +// if err := a.Run([]string{"run", "hello"}); err != nil { +// t.Logf("error running Run(): %+v", err) +// } +// expect(t, timeoutIsSet, true) +// expect(t, tIsSet, true) +// expect(t, passwordIsSet, true) +// expect(t, pIsSet, true) +// expect(t, passwordValue, "badpass") +// expect(t, unparsableIsSet, false) +// expect(t, noEnvVarIsSet, false) +// expect(t, nIsSet, false) +// expect(t, overrideIsSet, true) +// expect(t, oIsSet, true) +// expect(t, overrideValue, "overridden") +// +// _ = os.Setenv("APP_UNPARSABLE", "foobar") +// if err := a.Run([]string{"run"}); err != nil { +// t.Logf("error running Run(): %+v", err) +// } +// expect(t, unparsableIsSet, false) +// expect(t, uIsSet, false) +//} + func TestContext_NumFlags(t *testing.T) { set := flag.NewFlagSet("test", 0) set.Bool("myflag", false, "doc") @@ -177,8 +299,8 @@ func TestContext_NumFlags(t *testing.T) { globalSet.Bool("myflagGlobal", true, "doc") globalCtx := NewContext(nil, globalSet, nil) c := NewContext(nil, set, globalCtx) - set.Parse([]string{"--myflag", "--otherflag=foo"}) - globalSet.Parse([]string{"--myflagGlobal"}) + _ = set.Parse([]string{"--myflag", "--otherflag=foo"}) + _ = globalSet.Parse([]string{"--myflagGlobal"}) expect(t, c.NumFlags(), 2) } @@ -188,7 +310,7 @@ func TestContext_Set(t *testing.T) { c := NewContext(nil, set, nil) expect(t, c.IsSet("int"), false) - c.Set("int", "1") + _ = c.Set("int", "1") expect(t, c.Int("int"), 1) expect(t, c.IsSet("int"), true) } @@ -293,3 +415,153 @@ func TestContextPropagation(t *testing.T) { t.Fatal("expected context to not be nil even if the parent's context is nil") } } + +func TestCheckRequiredFlags(t *testing.T) { + tdata := []struct { + testCase string + parseInput []string + envVarInput [2]string + flags []Flag + expectedAnError bool + expectedErrorContents []string + }{ + { + testCase: "empty", + }, + { + testCase: "optional", + flags: []Flag{ + &StringFlag{Name: "optionalFlag"}, + }, + }, + { + testCase: "required", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true}, + }, + expectedAnError: true, + expectedErrorContents: []string{"requiredFlag"}, + }, + { + testCase: "required_and_present", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true}, + }, + parseInput: []string{"--requiredFlag", "myinput"}, + }, + { + testCase: "required_and_present_via_env_var", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true, EnvVar: "REQUIRED_FLAG"}, + }, + envVarInput: [2]string{"REQUIRED_FLAG", "true"}, + }, + { + testCase: "required_and_optional", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true}, + &StringFlag{Name: "optionalFlag"}, + }, + expectedAnError: true, + }, + { + testCase: "required_and_optional_and_optional_present", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true}, + &StringFlag{Name: "optionalFlag"}, + }, + parseInput: []string{"--optionalFlag", "myinput"}, + expectedAnError: true, + }, + { + testCase: "required_and_optional_and_optional_present_via_env_var", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true}, + &StringFlag{Name: "optionalFlag", EnvVar: "OPTIONAL_FLAG"}, + }, + envVarInput: [2]string{"OPTIONAL_FLAG", "true"}, + expectedAnError: true, + }, + { + testCase: "required_and_optional_and_required_present", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true}, + &StringFlag{Name: "optionalFlag"}, + }, + parseInput: []string{"--requiredFlag", "myinput"}, + }, + { + testCase: "two_required", + flags: []Flag{ + &StringFlag{Name: "requiredFlagOne", Required: true}, + &StringFlag{Name: "requiredFlagTwo", Required: true}, + }, + expectedAnError: true, + expectedErrorContents: []string{"requiredFlagOne", "requiredFlagTwo"}, + }, + { + testCase: "two_required_and_one_present", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true}, + &StringFlag{Name: "requiredFlagTwo", Required: true}, + }, + parseInput: []string{"--requiredFlag", "myinput"}, + expectedAnError: true, + }, + { + testCase: "two_required_and_both_present", + flags: []Flag{ + &StringFlag{Name: "requiredFlag", Required: true}, + &StringFlag{Name: "requiredFlagTwo", Required: true}, + }, + parseInput: []string{"--requiredFlag", "myinput", "--requiredFlagTwo", "myinput"}, + }, + { + testCase: "required_flag_with_short_name", + flags: []Flag{ + &StringSliceFlag{Name: "names, N", Required: true}, + }, + parseInput: []string{"-N", "asd", "-N", "qwe"}, + }, + { + testCase: "required_flag_with_multiple_short_names", + flags: []Flag{ + &StringSliceFlag{Name: "names, N, n", Required: true}, + }, + parseInput: []string{"-n", "asd", "-n", "qwe"}, + }, + } + for _, test := range tdata { + t.Run(test.testCase, func(t *testing.T) { + // setup + set := flag.NewFlagSet("test", 0) + for _, flags := range test.flags { + flags.Apply(set) + } + _ = set.Parse(test.parseInput) + if test.envVarInput[0] != "" { + os.Clearenv() + _ = os.Setenv(test.envVarInput[0], test.envVarInput[1]) + } + ctx := &Context{} + context := NewContext(ctx.App, set, ctx) + context.Command.Flags = test.flags + + // logic under test + err := checkRequiredFlags(test.flags, context) + + // assertions + if test.expectedAnError && err == nil { + t.Errorf("expected an error, but there was none") + } + if !test.expectedAnError && err != nil { + t.Errorf("did not expected an error, but there was one: %s", err) + } + for _, errString := range test.expectedErrorContents { + if !strings.Contains(err.Error(), errString) { + t.Errorf("expected error %q to contain %q, but it didn't!", err.Error(), errString) + } + } + }) + } +} diff --git a/docs.go b/docs.go new file mode 100644 index 0000000..5b94566 --- /dev/null +++ b/docs.go @@ -0,0 +1,148 @@ +package cli + +import ( + "bytes" + "fmt" + "io" + "sort" + "strings" + "text/template" + + "github.com/cpuguy83/go-md2man/v2/md2man" +) + +// ToMarkdown creates a markdown string for the `*App` +// The function errors if either parsing or writing of the string fails. +func (a *App) ToMarkdown() (string, error) { + var w bytes.Buffer + if err := a.writeDocTemplate(&w); err != nil { + return "", err + } + return w.String(), nil +} + +// ToMan creates a man page string for the `*App` +// The function errors if either parsing or writing of the string fails. +func (a *App) ToMan() (string, error) { + var w bytes.Buffer + if err := a.writeDocTemplate(&w); err != nil { + return "", err + } + man := md2man.Render(w.Bytes()) + return string(man), nil +} + +type cliTemplate struct { + App *App + Commands []string + GlobalArgs []string + SynopsisArgs []string +} + +func (a *App) writeDocTemplate(w io.Writer) error { + const name = "cli" + t, err := template.New(name).Parse(MarkdownDocTemplate) + if err != nil { + return err + } + return t.ExecuteTemplate(w, name, &cliTemplate{ + App: a, + Commands: prepareCommands(a.Commands, 0), + GlobalArgs: prepareArgsWithValues(a.Flags), + SynopsisArgs: prepareArgsSynopsis(a.Flags), + }) +} + +func prepareCommands(commands []Command, level int) []string { + coms := []string{} + for i := range commands { + command := &commands[i] + if command.Hidden { + continue + } + usage := "" + if command.Usage != "" { + usage = command.Usage + } + + prepared := fmt.Sprintf("%s %s\n\n%s\n", + strings.Repeat("#", level+2), + strings.Join(command.Names(), ", "), + usage, + ) + + flags := prepareArgsWithValues(command.Flags) + if len(flags) > 0 { + prepared += fmt.Sprintf("\n%s", strings.Join(flags, "\n")) + } + + coms = append(coms, prepared) + + // recursevly iterate subcommands + if len(command.Subcommands) > 0 { + coms = append( + coms, + prepareCommands(command.Subcommands, level+1)..., + ) + } + } + + return coms +} + +func prepareArgsWithValues(flags []Flag) []string { + return prepareFlags(flags, ", ", "**", "**", `""`, true) +} + +func prepareArgsSynopsis(flags []Flag) []string { + return prepareFlags(flags, "|", "[", "]", "[value]", false) +} + +func prepareFlags( + flags []Flag, + sep, opener, closer, value string, + addDetails bool, +) []string { + args := []string{} + for _, f := range flags { + flag, ok := f.(DocGenerationFlag) + if !ok { + continue + } + modifiedArg := opener + for _, s := range strings.Split(flag.GetName(), ",") { + trimmed := strings.TrimSpace(s) + if len(modifiedArg) > len(opener) { + modifiedArg += sep + } + if len(trimmed) > 1 { + modifiedArg += fmt.Sprintf("--%s", trimmed) + } else { + modifiedArg += fmt.Sprintf("-%s", trimmed) + } + } + modifiedArg += closer + if flag.TakesValue() { + modifiedArg += fmt.Sprintf("=%s", value) + } + + if addDetails { + modifiedArg += flagDetails(flag) + } + + args = append(args, modifiedArg+"\n") + + } + sort.Strings(args) + return args +} + +// flagDetails returns a string containing the flags metadata +func flagDetails(flag DocGenerationFlag) string { + description := flag.GetUsage() + value := flag.GetValue() + if value != "" { + description += " (default: " + value + ")" + } + return ": " + description +} diff --git a/docs_test.go b/docs_test.go new file mode 100644 index 0000000..f18d12d --- /dev/null +++ b/docs_test.go @@ -0,0 +1,122 @@ +package cli + +import ( + "io/ioutil" + "testing" +) + +func testApp() *App { + app := NewApp() + app.Name = "greet" + app.Flags = []Flag{ + StringFlag{ + Name: "socket, s", + Usage: "some 'usage' text", + Value: "value", + TakesFile: true, + }, + StringFlag{Name: "flag, fl, f"}, + BoolFlag{ + Name: "another-flag, b", + Usage: "another usage text", + }, + } + app.Commands = []Command{{ + Aliases: []string{"c"}, + Flags: []Flag{ + StringFlag{ + Name: "flag, fl, f", + TakesFile: true, + }, + BoolFlag{ + Name: "another-flag, b", + Usage: "another usage text", + }, + }, + Name: "config", + Usage: "another usage test", + Subcommands: []Command{{ + Aliases: []string{"s", "ss"}, + Flags: []Flag{ + StringFlag{Name: "sub-flag, sub-fl, s"}, + BoolFlag{ + Name: "sub-command-flag, s", + Usage: "some usage text", + }, + }, + Name: "sub-config", + Usage: "another usage test", + }}, + }, { + Aliases: []string{"i", "in"}, + Name: "info", + Usage: "retrieve generic information", + }, { + Name: "some-command", + }, { + Name: "hidden-command", + Hidden: true, + }} + app.UsageText = "app [first_arg] [second_arg]" + app.Usage = "Some app" + app.Author = "Harrison" + app.Email = "harrison@lolwut.com" + app.Authors = []Author{{Name: "Oliver Allen", Email: "oliver@toyshop.com"}} + return app +} + +func expectFileContent(t *testing.T, file, expected string) { + data, err := ioutil.ReadFile(file) + expect(t, err, nil) + expect(t, string(data), expected) +} + +func TestToMarkdownFull(t *testing.T) { + // Given + app := testApp() + + // When + res, err := app.ToMarkdown() + + // Then + expect(t, err, nil) + expectFileContent(t, "testdata/expected-doc-full.md", res) +} + +func TestToMarkdownNoFlags(t *testing.T) { + // Given + app := testApp() + app.Flags = nil + + // When + res, err := app.ToMarkdown() + + // Then + expect(t, err, nil) + expectFileContent(t, "testdata/expected-doc-no-flags.md", res) +} + +func TestToMarkdownNoCommands(t *testing.T) { + // Given + app := testApp() + app.Commands = nil + + // When + res, err := app.ToMarkdown() + + // Then + expect(t, err, nil) + expectFileContent(t, "testdata/expected-doc-no-commands.md", res) +} + +func TestToMan(t *testing.T) { + // Given + app := testApp() + + // When + res, err := app.ToMan() + + // Then + expect(t, err, nil) + expectFileContent(t, "testdata/expected-doc-full.man", res) +} diff --git a/errors.go b/errors.go index 6259699..2f12338 100644 --- a/errors.go +++ b/errors.go @@ -59,25 +59,33 @@ type ExitCoder interface { ExitCode() int } -type exitError struct { +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, + } +} + // Exit wraps a message and exit code into an ExitCoder suitable for handling by // HandleExitCoder func Exit(message interface{}, exitCode int) ExitCoder { - return &exitError{ + return &ExitError{ exitCode: exitCode, message: message, } } -func (ee *exitError) Error() string { +func (ee *ExitError) Error() string { return fmt.Sprintf("%v", ee.message) } -func (ee *exitError) ExitCode() int { +func (ee *ExitError) ExitCode() int { return ee.exitCode } diff --git a/fish.go b/fish.go new file mode 100644 index 0000000..cf183af --- /dev/null +++ b/fish.go @@ -0,0 +1,194 @@ +package cli + +import ( + "bytes" + "fmt" + "io" + "strings" + "text/template" +) + +// ToFishCompletion creates a fish completion string for the `*App` +// The function errors if either parsing or writing of the string fails. +func (a *App) ToFishCompletion() (string, error) { + var w bytes.Buffer + if err := a.writeFishCompletionTemplate(&w); err != nil { + return "", err + } + return w.String(), nil +} + +type fishCompletionTemplate struct { + App *App + Completions []string + AllCommands []string +} + +func (a *App) writeFishCompletionTemplate(w io.Writer) error { + const name = "cli" + t, err := template.New(name).Parse(FishCompletionTemplate) + if err != nil { + return err + } + allCommands := []string{} + + // Add global flags + completions := a.prepareFishFlags(a.VisibleFlags(), allCommands) + + // Add help flag + if !a.HideHelp { + completions = append( + completions, + a.prepareFishFlags([]Flag{HelpFlag}, allCommands)..., + ) + } + + // Add version flag + if !a.HideVersion { + completions = append( + completions, + a.prepareFishFlags([]Flag{VersionFlag}, allCommands)..., + ) + } + + // Add commands and their flags + completions = append( + completions, + a.prepareFishCommands(a.VisibleCommands(), &allCommands, []string{})..., + ) + + return t.ExecuteTemplate(w, name, &fishCompletionTemplate{ + App: a, + Completions: completions, + AllCommands: allCommands, + }) +} + +func (a *App) prepareFishCommands(commands []Command, allCommands *[]string, previousCommands []string) []string { + completions := []string{} + for i := range commands { + command := &commands[i] + + if command.Hidden { + continue + } + + var completion strings.Builder + completion.WriteString(fmt.Sprintf( + "complete -r -c %s -n '%s' -a '%s'", + a.Name, + a.fishSubcommandHelper(previousCommands), + strings.Join(command.Names(), " "), + )) + + if command.Usage != "" { + completion.WriteString(fmt.Sprintf(" -d '%s'", + escapeSingleQuotes(command.Usage))) + } + + if !command.HideHelp { + completions = append( + completions, + a.prepareFishFlags([]Flag{HelpFlag}, command.Names())..., + ) + } + + *allCommands = append(*allCommands, command.Names()...) + completions = append(completions, completion.String()) + completions = append( + completions, + a.prepareFishFlags(command.Flags, command.Names())..., + ) + + // recursevly iterate subcommands + if len(command.Subcommands) > 0 { + completions = append( + completions, + a.prepareFishCommands( + command.Subcommands, allCommands, command.Names(), + )..., + ) + } + } + + return completions +} + +func (a *App) prepareFishFlags(flags []Flag, previousCommands []string) []string { + completions := []string{} + for _, f := range flags { + flag, ok := f.(DocGenerationFlag) + if !ok { + continue + } + + completion := &strings.Builder{} + completion.WriteString(fmt.Sprintf( + "complete -c %s -n '%s'", + a.Name, + a.fishSubcommandHelper(previousCommands), + )) + + fishAddFileFlag(f, completion) + + for idx, opt := range strings.Split(flag.GetName(), ",") { + if idx == 0 { + completion.WriteString(fmt.Sprintf( + " -l %s", strings.TrimSpace(opt), + )) + } else { + completion.WriteString(fmt.Sprintf( + " -s %s", strings.TrimSpace(opt), + )) + + } + } + + if flag.TakesValue() { + completion.WriteString(" -r") + } + + if flag.GetUsage() != "" { + completion.WriteString(fmt.Sprintf(" -d '%s'", + escapeSingleQuotes(flag.GetUsage()))) + } + + completions = append(completions, completion.String()) + } + + return completions +} + +func fishAddFileFlag(flag Flag, completion *strings.Builder) { + switch f := flag.(type) { + case GenericFlag: + if f.TakesFile { + return + } + case StringFlag: + if f.TakesFile { + return + } + case StringSliceFlag: + if f.TakesFile { + return + } + } + completion.WriteString(" -f") +} + +func (a *App) fishSubcommandHelper(allCommands []string) string { + fishHelper := fmt.Sprintf("__fish_%s_no_subcommand", a.Name) + if len(allCommands) > 0 { + fishHelper = fmt.Sprintf( + "__fish_seen_subcommand_from %s", + strings.Join(allCommands, " "), + ) + } + return fishHelper + +} + +func escapeSingleQuotes(input string) string { + return strings.Replace(input, `'`, `\'`, -1) +} diff --git a/fish_test.go b/fish_test.go new file mode 100644 index 0000000..a4c1871 --- /dev/null +++ b/fish_test.go @@ -0,0 +1,17 @@ +package cli + +import ( + "testing" +) + +func TestFishCompletion(t *testing.T) { + // Given + app := testApp() + + // When + res, err := app.ToFishCompletion() + + // Then + expect(t, err, nil) + expectFileContent(t, "testdata/expected-fish-full.fish", res) +} diff --git a/flag-types.json b/flag-types.json deleted file mode 100644 index bd5ec3f..0000000 --- a/flag-types.json +++ /dev/null @@ -1,98 +0,0 @@ -[ - { - "name": "Bool", - "type": "bool", - "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": "Float64Slice", - "type": "*Float64Slice", - "dest": false, - "context_default": "nil", - "context_type": "[]float64", - "parser": "(f.Value.(*Float64Slice)).Value(), error(nil)" - }, - { - "name": "String", - "type": "string", - "context_default": "\"\"", - "parser": "f.Value.String(), error(nil)" - }, - { - "name": "Path", - "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)" - } -] diff --git a/flag.go b/flag.go index 364362c..6a32574 100644 --- a/flag.go +++ b/flag.go @@ -1,9 +1,9 @@ package cli import ( - "encoding/json" "flag" "fmt" + "io/ioutil" "reflect" "regexp" "runtime" @@ -22,50 +22,66 @@ var ( ) // GenerateCompletionFlag enables completion for all commands and subcommands -var GenerateCompletionFlag Flag = &BoolFlag{ - Name: "generate-completion", +//var GenerateCompletionFlag Flag = &BoolFlag{ +// Name: "generate-completion", +// Hidden: true, +//} +// +//func genCompName() string { +// names := GenerateCompletionFlag.Names() +// if len(names) == 0 { +// return "generate-completion" +// } +// return names[0] +//} +// +//// InitCompletionFlag generates completion code +//var InitCompletionFlag = &StringFlag{ +// Name: "init-completion", +// Usage: "generate completion code. Value must be 'bash' or 'zsh'", +//} + +// BashCompletionFlag enables bash-completion for all commands and subcommands +var BashCompletionFlag Flag = &BoolFlag{ + Name: "generate-bash-completion", Hidden: true, } -func genCompName() string { - names := GenerateCompletionFlag.Names() - if len(names) == 0 { - return "generate-completion" - } - return names[0] -} - -// InitCompletionFlag generates completion code -var InitCompletionFlag = &StringFlag{ - Name: "init-completion", - Usage: "generate completion code. Value must be 'bash' or 'zsh'", -} - // VersionFlag prints the version for the application var VersionFlag Flag = &BoolFlag{ - Name: "version", - Aliases: []string{"v"}, - Usage: "print the version", + Name: "version, v", + Usage: "print the version", } // HelpFlag prints the help for all commands and subcommands. // Set to nil to disable the flag. The subcommand // will still be added unless HideHelp is set to true. var HelpFlag Flag = &BoolFlag{ - Name: "help", - Aliases: []string{"h"}, - Usage: "show help", + 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 -// Serializeder is used to circumvent the limitations of flag.FlagSet.Set -type Serializeder interface { - Serialized() string +// Serializer is used to circumvent the limitations of flag.FlagSet.Set +type Serializer interface { + Serialize() string } +// 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 @@ -74,12 +90,16 @@ func (f FlagsByName) Len() int { } func (f FlagsByName) Less(i, j int) bool { + //<<<<<<< HEAD if len(f[j].Names()) == 0 { return false } else if len(f[i].Names()) == 0 { return true } return f[i].Names()[0] < f[j].Names()[0] + //======= + // return lexicographicLess(f[i].GetName(), f[j].GetName()) + //>>>>>>> master } func (f FlagsByName) Swap(i, j int) { @@ -92,711 +112,59 @@ func (f FlagsByName) Swap(i, j int) { type Flag interface { fmt.Stringer // Apply Flag settings to the given flag set - Apply(*flag.FlagSet) + Apply(*flag.FlagSet) error Names() []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 { +// RequiredFlag is an interface that allows us to mark flags as required +// it allows flags required flags to be backwards compatible with the Flag interface +type RequiredFlag 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 -} - -// 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - val.Set(envVal) - break - } - } - } - - for _, name := range f.Names() { - set.Var(val, name, f.Usage) - } - return nil -} - -// StringSlice wraps a []string to satisfy flag.Value -type StringSlice struct { - slice []string - hasBeenSet bool -} - -// NewStringSlice creates a *StringSlice with default values -func NewStringSlice(defaults ...string) *StringSlice { - return &StringSlice{slice: append([]string{}, defaults...)} -} - -// Set appends the string value to the list of values -func (f *StringSlice) Set(value string) error { - if !f.hasBeenSet { - f.slice = []string{} - f.hasBeenSet = true - } - - if strings.HasPrefix(value, slPfx) { - // Deserializing assumes overwrite - _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &f.slice) - f.hasBeenSet = true - return nil - } - - f.slice = append(f.slice, value) - return nil -} - -// String returns a readable representation of this value (for usage defaults) -func (f *StringSlice) String() string { - return fmt.Sprintf("%s", f.slice) -} - -// Serialized allows StringSlice to fulfill Serializeder -func (f *StringSlice) Serialized() string { - jsonBytes, _ := json.Marshal(f.slice) - return fmt.Sprintf("%s%s", slPfx, string(jsonBytes)) -} - -// Value returns the slice of strings set by this flag -func (f *StringSlice) Value() []string { - return f.slice -} - -// 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - newVal := NewStringSlice() - for _, s := range strings.Split(envVal, ",") { - s = strings.TrimSpace(s) - if err := newVal.Set(s); err != nil { - return fmt.Errorf("could not parse %q as string value for flag %s: %s", envVal, f.Name, err) - } - } - f.Value = newVal - break - } - } - } - - if f.Value == nil { - f.Value = NewStringSlice() - } - - for _, name := range f.Names() { - set.Var(f.Value, name, f.Usage) - } - return nil -} - -// IntSlice wraps an []int to satisfy flag.Value -type IntSlice struct { - slice []int - hasBeenSet bool -} - -// NewIntSlice makes an *IntSlice with default values -func NewIntSlice(defaults ...int) *IntSlice { - return &IntSlice{slice: append([]int{}, defaults...)} -} - -// NewInt64Slice makes an *Int64Slice with default values -func NewInt64Slice(defaults ...int64) *Int64Slice { - return &Int64Slice{slice: append([]int64{}, defaults...)} -} - -// SetInt directly adds an integer to the list of values -func (i *IntSlice) SetInt(value int) { - if !i.hasBeenSet { - i.slice = []int{} - i.hasBeenSet = true - } - - i.slice = append(i.slice, value) -} - -// Set parses the value into an integer and appends it to the list of values -func (i *IntSlice) Set(value string) error { - if !i.hasBeenSet { - i.slice = []int{} - i.hasBeenSet = true - } - - if strings.HasPrefix(value, slPfx) { - // Deserializing assumes overwrite - _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &i.slice) - i.hasBeenSet = true - return nil - } - - tmp, err := strconv.ParseInt(value, 0, 64) - if err != nil { - return err - } - - i.slice = append(i.slice, int(tmp)) - return nil -} - -// String returns a readable representation of this value (for usage defaults) -func (f *IntSlice) String() string { - return fmt.Sprintf("%#v", f.slice) -} - -// Serialized allows IntSlice to fulfill Serializeder -func (i *IntSlice) Serialized() string { - jsonBytes, _ := json.Marshal(i.slice) - return fmt.Sprintf("%s%s", slPfx, string(jsonBytes)) -} - -// Value returns the slice of ints set by this flag -func (i *IntSlice) Value() []int { - return i.slice -} - -// 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - newVal := NewIntSlice() - for _, s := range strings.Split(envVal, ",") { - s = strings.TrimSpace(s) - if err := newVal.Set(s); err != nil { - return fmt.Errorf("could not parse %q as int slice value for flag %s: %s", envVal, f.Name, err) - } - } - f.Value = newVal - break - } - } - } - - if f.Value == nil { - f.Value = NewIntSlice() - } - - for _, name := range f.Names() { - set.Var(f.Value, name, f.Usage) - } - return nil -} - -// Int64Slice is an opaque type for []int to satisfy flag.Value -type Int64Slice struct { - slice []int64 - hasBeenSet bool -} - -// Set parses the value into an integer and appends it to the list of values -func (f *Int64Slice) Set(value string) error { - if !f.hasBeenSet { - f.slice = []int64{} - f.hasBeenSet = true - } - - if strings.HasPrefix(value, slPfx) { - // Deserializing assumes overwrite - _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &f.slice) - f.hasBeenSet = true - return nil - } - - tmp, err := strconv.ParseInt(value, 0, 64) - if err != nil { - return err - } - - f.slice = append(f.slice, tmp) - return nil -} - -// String returns a readable representation of this value (for usage defaults) -func (f *Int64Slice) String() string { - return fmt.Sprintf("%#v", f.slice) -} - -// Serialized allows Int64Slice to fulfill Serializeder -func (f *Int64Slice) Serialized() string { - jsonBytes, _ := json.Marshal(f.slice) - return fmt.Sprintf("%s%s", slPfx, string(jsonBytes)) -} - -// Value returns the slice of ints set by this flag -func (f *Int64Slice) Value() []int64 { - return f.slice -} - -// 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - newVal := NewInt64Slice() - for _, s := range strings.Split(envVal, ",") { - s = strings.TrimSpace(s) - if err := newVal.Set(s); err != nil { - return fmt.Errorf("could not parse %q as int64 slice value for flag %s: %s", envVal, f.Name, err) - } - } - f.Value = newVal - break - } - } - } - - if f.Value == nil { - f.Value = NewInt64Slice() - } - - for _, name := range f.Names() { - 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 { - if f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - if envVal == "" { - f.Value = false - break - } - - envValBool, err := strconv.ParseBool(envVal) - if err != nil { - return fmt.Errorf("could not parse %q as bool value for flag %s: %s", envVal, f.Name, err) - } - f.Value = envValBool - break - } - } - } - - for _, name := range f.Names() { - if f.Destination != nil { - set.BoolVar(f.Destination, name, f.Value, f.Usage) - continue - } - set.Bool(name, f.Value, 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - f.Value = envVal - break - } - } - } - - for _, name := range f.Names() { - if f.Destination != nil { - set.StringVar(f.Destination, name, f.Value, f.Usage) - continue - } - set.String(name, f.Value, f.Usage) - } - return nil -} - -// Apply populates the flag given the flag set and environment -// Ignores errors -func (f *PathFlag) Apply(set *flag.FlagSet) { - f.ApplyWithError(set) -} - -// ApplyWithError populates the flag given the flag set and environment -func (f *PathFlag) ApplyWithError(set *flag.FlagSet) error { - if f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - f.Value = envVal - break - } - } - } - - for _, name := range f.Names() { - if f.Destination != nil { - set.StringVar(f.Destination, name, f.Value, f.Usage) - continue - } - 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - envValInt, err := strconv.ParseInt(envVal, 0, 64) - if err != nil { - return fmt.Errorf("could not parse %q as int value for flag %s: %s", envVal, f.Name, err) - } - f.Value = int(envValInt) - break - } - } - } - - for _, name := range f.Names() { - if f.Destination != nil { - set.IntVar(f.Destination, name, f.Value, f.Usage) - continue - } - 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - envValInt, err := strconv.ParseInt(envVal, 0, 64) - if err != nil { - return fmt.Errorf("could not parse %q as int value for flag %s: %s", envVal, f.Name, err) - } - - f.Value = envValInt - break - } - } - } - - for _, name := range f.Names() { - if f.Destination != nil { - set.Int64Var(f.Destination, name, f.Value, f.Usage) - return nil - } - 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - envValInt, err := strconv.ParseUint(envVal, 0, 64) - if err != nil { - return fmt.Errorf("could not parse %q as uint value for flag %s: %s", envVal, f.Name, err) - } - - f.Value = uint(envValInt) - break - } - } - } - - for _, name := range f.Names() { - if f.Destination != nil { - set.UintVar(f.Destination, name, f.Value, f.Usage) - return nil - } - 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 f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - envValInt, err := strconv.ParseUint(envVal, 0, 64) - if err != nil { - return fmt.Errorf("could not parse %q as uint64 value for flag %s: %s", envVal, f.Name, err) - } - - f.Value = uint64(envValInt) - break - } - } - } - - for _, name := range f.Names() { - if f.Destination != nil { - set.Uint64Var(f.Destination, name, f.Value, f.Usage) - return nil - } - 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) + IsRequired() bool } -// ApplyWithError populates the flag given the flag set and environment -func (f *DurationFlag) ApplyWithError(set *flag.FlagSet) error { - if f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - envValDuration, err := time.ParseDuration(envVal) - if err != nil { - return fmt.Errorf("could not parse %q as duration for flag %s: %s", envVal, f.Name, err) - } +// DocGenerationFlag is an interface that allows documentation generation for the flag +type DocGenerationFlag interface { + Flag - f.Value = envValDuration - break - } - } - } + // TakesValue returns true of the flag takes a value, otherwise false + TakesValue() bool - for _, name := range f.Names() { - if f.Destination != nil { - set.DurationVar(f.Destination, name, f.Value, f.Usage) - continue - } - set.Duration(name, f.Value, f.Usage) - } - return nil -} + // GetUsage returns the usage string for the flag + GetUsage() string -// Apply populates the flag given the flag set and environment -// Ignores errors -func (f *Float64Flag) Apply(set *flag.FlagSet) { - f.ApplyWithError(set) + // GetValue returns the flags value as string representation and an empty + // string if the flag takes no value at all. + GetValue() string } -// ApplyWithError populates the flag given the flag set and environment -func (f *Float64Flag) ApplyWithError(set *flag.FlagSet) error { - if f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - envValFloat, err := strconv.ParseFloat(envVal, 10) - if err != nil { - return fmt.Errorf("could not parse %q as float64 value for flag %s: %s", envVal, f.Name, err) - } - - f.Value = float64(envValFloat) - break - } - } - } +func flagSet(name string, flags []Flag) (*flag.FlagSet, error) { + set := flag.NewFlagSet(name, flag.ContinueOnError) - for _, name := range f.Names() { - if f.Destination != nil { - set.Float64Var(f.Destination, name, f.Value, f.Usage) - continue + for _, f := range flags { + if err := f.Apply(set); err != nil { + return nil, err } - set.Float64(name, f.Value, f.Usage) - } - return nil -} - -// NewFloat64Slice makes a *Float64Slice with default values -func NewFloat64Slice(defaults ...float64) *Float64Slice { - return &Float64Slice{slice: append([]float64{}, defaults...)} -} - -// Float64Slice is an opaque type for []float64 to satisfy flag.Value -type Float64Slice struct { - slice []float64 - hasBeenSet bool -} - -// Set parses the value into a float64 and appends it to the list of values -func (f *Float64Slice) Set(value string) error { - if !f.hasBeenSet { - f.slice = []float64{} - f.hasBeenSet = true } - - if strings.HasPrefix(value, slPfx) { - // Deserializing assumes overwrite - _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &f.slice) - f.hasBeenSet = true - return nil - } - - tmp, err := strconv.ParseFloat(value, 64) - if err != nil { - return err - } - - f.slice = append(f.slice, tmp) - return nil -} - -// String returns a readable representation of this value (for usage defaults) -func (f *Float64Slice) String() string { - return fmt.Sprintf("%#v", f.slice) -} - -// Serialized allows Float64Slice to fulfill Serializeder -func (f *Float64Slice) Serialized() string { - jsonBytes, _ := json.Marshal(f.slice) - return fmt.Sprintf("%s%s", slPfx, string(jsonBytes)) -} - -// Value returns the slice of float64s set by this flag -func (f *Float64Slice) Value() []float64 { - return f.slice -} - -// Apply populates the flag given the flag set and environment -// Ignores errors -func (f *Float64SliceFlag) Apply(set *flag.FlagSet) { - f.ApplyWithError(set) + set.SetOutput(ioutil.Discard) + return set, nil } -// ApplyWithError populates the flag given the flag set and environment -func (f *Float64SliceFlag) ApplyWithError(set *flag.FlagSet) error { - if f.EnvVars != nil { - for _, envVar := range f.EnvVars { - if envVal, ok := syscall.Getenv(envVar); ok { - newVal := NewFloat64Slice() - for _, s := range strings.Split(envVal, ",") { - s = strings.TrimSpace(s) - err := newVal.Set(s) - if err != nil { - fmt.Fprintf(ErrWriter, err.Error()) - } - } - f.Value = newVal - break - } - } - } - - if f.Value == nil { - f.Value = NewFloat64Slice() +func eachName(longName string, fn func(string)) { + parts := strings.Split(longName, ",") + for _, name := range parts { + name = strings.Trim(name, " ") + fn(name) } - - for _, name := range f.Names() { - set.Var(f.Value, name, f.Usage) - } - return nil } func visibleFlags(fl []Flag) []Flag { - visible := []Flag{} - for _, flag := range fl { - field := flagValue(flag).FieldByName("Hidden") + var visible []Flag + for _, f := range fl { + field := flagValue(f).FieldByName("Hidden") if !field.IsValid() || !field.Bool() { - visible = append(visible, flag) + visible = append(visible, f) } } return visible @@ -858,6 +226,7 @@ func withEnvHint(envVars []string, str string) string { suffix = "%" sep = "%, %" } + envText = fmt.Sprintf(" [%s%s%s]", prefix, strings.Join(envVars, sep), suffix) } return str + envText @@ -902,6 +271,14 @@ func flagStringField(f Flag, name string) string { return "" } +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 { @@ -956,14 +333,14 @@ func stringifyFlag(f Flag) string { placeholder = defaultPlaceholder } - usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultValueString)) + usageWithDefault := strings.TrimSpace(usage + defaultValueString) return withEnvHint(flagStringSliceField(f, "EnvVars"), fmt.Sprintf("%s\t%s", prefixedNames(f.Names(), placeholder), usageWithDefault)) } func stringifyIntSliceFlag(f *IntSliceFlag) string { - defaultVals := []string{} + var defaultVals []string if f.Value != nil && len(f.Value.Value()) > 0 { for _, i := range f.Value.Value() { defaultVals = append(defaultVals, fmt.Sprintf("%d", i)) @@ -974,10 +351,10 @@ func stringifyIntSliceFlag(f *IntSliceFlag) string { } func stringifyInt64SliceFlag(f *Int64SliceFlag) string { - defaultVals := []string{} + var defaultVals []string if f.Value != nil && len(f.Value.Value()) > 0 { for _, i := range f.Value.Value() { - defaultVals = append(defaultVals, fmt.Sprintf("%d", i)) + defaultVals = append(defaultVals, strconv.FormatInt(i, 10)) } } @@ -985,7 +362,8 @@ func stringifyInt64SliceFlag(f *Int64SliceFlag) string { } func stringifyFloat64SliceFlag(f *Float64SliceFlag) string { - defaultVals := []string{} + var defaultVals []string + if f.Value != nil && len(f.Value.Value()) > 0 { for _, i := range f.Value.Value() { defaultVals = append(defaultVals, strings.TrimRight(strings.TrimRight(fmt.Sprintf("%f", i), "0"), ".")) @@ -996,11 +374,12 @@ func stringifyFloat64SliceFlag(f *Float64SliceFlag) string { } func stringifyStringSliceFlag(f *StringSliceFlag) string { - defaultVals := []string{} + var defaultVals []string + if f.Value != nil && len(f.Value.Value()) > 0 { for _, s := range f.Value.Value() { if len(s) > 0 { - defaultVals = append(defaultVals, fmt.Sprintf("%q", s)) + defaultVals = append(defaultVals, strconv.Quote(s)) } } } @@ -1032,3 +411,18 @@ func hasFlag(flags []Flag, fl Flag) bool { return false } + +func flagFromEnvOrFile(envVars []string, filePath string) (val string, ok bool) { + for _, envVar := range envVars { + envVar = strings.TrimSpace(envVar) + if val, ok := syscall.Getenv(envVar); ok { + return val, true + } + } + for _, fileVar := range strings.Split(filePath, ",") { + if data, err := ioutil.ReadFile(fileVar); err == nil { + return string(data), true + } + } + return "", false +} diff --git a/flag_bool.go b/flag_bool.go new file mode 100644 index 0000000..665a8ac --- /dev/null +++ b/flag_bool.go @@ -0,0 +1,107 @@ +package cli + +import ( + "flag" + "fmt" + "strconv" +) + +// BoolFlag is a flag with type bool +type BoolFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value bool + DefaultText string + Destination *bool +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *BoolFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *BoolFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *BoolFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *BoolFlag) TakesValue() bool { + return false +} + +// GetUsage returns the usage string for the flag +func (f *BoolFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *BoolFlag) GetValue() string { + return "" +} + +// Apply populates the flag given the flag set and environment +func (f *BoolFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + if val != "" { + valBool, err := strconv.ParseBool(val) + if err != nil { + return fmt.Errorf("could not parse %s as bool value for flag %s: %s", val, f.Name, err) + } + f.Value = valBool + } + } + + for _, name := range f.Names() { + if f.Destination != nil { + set.BoolVar(f.Destination, name, f.Value, f.Usage) + continue + } + set.Bool(name, f.Value, f.Usage) + } + + return nil +} + +// Bool looks up the value of a local BoolFlag, returns +// false if not found +func (c *Context) Bool(name string) bool { + if fs := lookupFlagSet(name, c); fs != nil { + return lookupBool(name, fs) + } + return false +} + +// 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 +//} + +// TODO: Fix Duplicate +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 +} diff --git a/flag_duration.go b/flag_duration.go new file mode 100644 index 0000000..e3ccd18 --- /dev/null +++ b/flag_duration.go @@ -0,0 +1,104 @@ +package cli + +import ( + "flag" + "fmt" + "time" +) + +// DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration) +type DurationFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value time.Duration + DefaultText string + Destination *time.Duration +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *DurationFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *DurationFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *DurationFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *DurationFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *DurationFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *DurationFlag) GetValue() string { + return f.Value.String() +} + +// Apply populates the flag given the flag set and environment +func (f *DurationFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + if val != ""{ + valDuration, err := time.ParseDuration(val) + if err != nil { + return fmt.Errorf("could not parse %s as duration value for flag %s: %s", val, f.Name, err) + } + f.Value = valDuration + } + } + + for _, name := range f.Names() { + if f.Destination != nil { + set.DurationVar(f.Destination, name, f.Value, f.Usage) + continue + } + set.Duration(name, f.Value, f.Usage) + } + return nil +} + +// Duration looks up the value of a local DurationFlag, returns +// 0 if not found +func (c *Context) Duration(name string) time.Duration { + if fs := lookupFlagSet(name, c); fs != nil { + return lookupDuration(name, fs) + } + return 0 +} +// 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 +} diff --git a/flag_float64.go b/flag_float64.go new file mode 100644 index 0000000..641cb0b --- /dev/null +++ b/flag_float64.go @@ -0,0 +1,106 @@ +package cli + +import ( + "flag" + "fmt" + "strconv" +) + +// Float64Flag is a flag with type float64 +type Float64Flag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value float64 + DefaultText string + Destination *float64 +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *Float64Flag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *Float64Flag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *Float64Flag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *Float64Flag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *Float64Flag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *Float64Flag) GetValue() string { + return fmt.Sprintf("%f", f.Value) +} + +// Apply populates the flag given the flag set and environment +func (f *Float64Flag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + if val != "" { + valFloat, err := strconv.ParseFloat(val, 10) + if err != nil { + return fmt.Errorf("could not parse %s as float64 value for flag %s: %s", val, f.Name, err) + } + f.Value = valFloat + } + } + + for _, name := range f.Names() { + if f.Destination != nil { + set.Float64Var(f.Destination, name, f.Value, f.Usage) + continue + } + set.Float64(name, f.Value, f.Usage) + } + + return nil +} + +// Float64 looks up the value of a local Float64Flag, returns +// 0 if not found +func (c *Context) Float64(name string) float64 { + if fs := lookupFlagSet(name, c); fs != nil { + return lookupFloat64(name, fs) + } + return 0 +} + +// 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 +} diff --git a/flag_float64_slice.go b/flag_float64_slice.go new file mode 100644 index 0000000..8331c43 --- /dev/null +++ b/flag_float64_slice.go @@ -0,0 +1,164 @@ +package cli + +import ( + "encoding/json" + "flag" + "fmt" + "strconv" + "strings" +) + +// Float64Slice wraps []float64 to satisfy flag.Value +type Float64Slice struct { + slice []float64 + hasBeenSet bool +} + +// NewFloat64Slice makes a *Float64Slice with default values +func NewFloat64Slice(defaults ...float64) *Float64Slice { + return &Float64Slice{slice: append([]float64{}, defaults...)} +} + +// Set parses the value into a float64 and appends it to the list of values +func (f *Float64Slice) Set(value string) error { + if !f.hasBeenSet { + f.slice = []float64{} + f.hasBeenSet = true + } + + if strings.HasPrefix(value, slPfx) { + // Deserializing assumes overwrite + _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &f.slice) + f.hasBeenSet = true + return nil + } + + tmp, err := strconv.ParseFloat(value, 64) + if err != nil { + return err + } + + f.slice = append(f.slice, tmp) + return nil +} + +// String returns a readable representation of this value (for usage defaults) +func (f *Float64Slice) String() string { + return fmt.Sprintf("%#v", f.slice) +} + +// Serialize allows Float64Slice to fulfill Serializer +func (f *Float64Slice) Serialize() string { + jsonBytes, _ := json.Marshal(f.slice) + return fmt.Sprintf("%s%s", slPfx, string(jsonBytes)) +} + +// Value returns the slice of float64s set by this flag +func (f *Float64Slice) Value() []float64 { + return f.slice +} + +// Get returns the slice of float64s set by this flag +func (f *Float64Slice) Get() interface{} { + return *f +} + +// Float64SliceFlag is a flag with type *Float64Slice +type Float64SliceFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value *Float64Slice + DefaultText string +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *Float64SliceFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *Float64SliceFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *Float64SliceFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true if the flag takes a value, otherwise false +func (f *Float64SliceFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *Float64SliceFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *Float64SliceFlag) GetValue() string { + if f.Value != nil { + return f.Value.String() + } + return "" +} + +// Apply populates the flag given the flag set and environment +func (f *Float64SliceFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + f.Value = &Float64Slice{} + + for _, s := range strings.Split(val, ",") { + if err := f.Value.Set(strings.TrimSpace(s)); err != nil { + return fmt.Errorf("could not parse %s as float64 slice value for flag %s: %s", f.Value, f.Name, err) + } + } + } + + for _, name := range f.Names() { + if f.Value == nil { + f.Value = &Float64Slice{} + } + set.Var(f.Value, name, f.Usage) + } + + return nil +} + +// Float64Slice looks up the value of a local Float64SliceFlag, returns +// nil if not found +func (c *Context) Float64Slice(name string) []float64 { + if fs := lookupFlagSet(name, c); fs != nil { + return lookupFloat64Slice(name, fs) + } + return nil +} + +// GlobalFloat64Slice looks up the value of a global Float64SliceFlag, returns +// nil if not found +//func (c *Context) GlobalFloat64Slice(name string) []int { +// if fs := lookupGlobalFlagSet(name, c); fs != nil { +// return lookupFloat64Slice(name, fs) +// } +// return nil +//} + +func lookupFloat64Slice(name string, set *flag.FlagSet) []float64 { + f := set.Lookup(name) + if f != nil { + parsed, err := (f.Value.(*Float64Slice)).Value(), error(nil) + if err != nil { + return nil + } + return parsed + } + return nil +} diff --git a/flag_generated.go b/flag_generated.go deleted file mode 100644 index a958150..0000000 --- a/flag_generated.go +++ /dev/null @@ -1,629 +0,0 @@ -package cli - -import ( - "flag" - "strconv" - "time" -) - -// WARNING: This file is generated! - -// BoolFlag is a flag with type bool -type BoolFlag struct { - Name string - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value bool - DefaultText string - - Destination *bool -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *BoolFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *BoolFlag) Names() []string { - return flagNames(f) -} - -// Bool looks up the value of a local BoolFlag, returns -// false if not found -func (c *Context) Bool(name string) bool { - if fs := lookupFlagSet(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 -} - -// DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration) -type DurationFlag struct { - Name string - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value time.Duration - DefaultText string - - Destination *time.Duration -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *DurationFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *DurationFlag) Names() []string { - return flagNames(f) -} - -// Duration looks up the value of a local DurationFlag, returns -// 0 if not found -func (c *Context) Duration(name string) time.Duration { - if fs := lookupFlagSet(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value float64 - DefaultText string - - Destination *float64 -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *Float64Flag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *Float64Flag) Names() []string { - return flagNames(f) -} - -// Float64 looks up the value of a local Float64Flag, returns -// 0 if not found -func (c *Context) Float64(name string) float64 { - if fs := lookupFlagSet(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value Generic - DefaultText string -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *GenericFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *GenericFlag) Names() []string { - return flagNames(f) -} - -// Generic looks up the value of a local GenericFlag, returns -// nil if not found -func (c *Context) Generic(name string) interface{} { - if fs := lookupFlagSet(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value int64 - DefaultText string - - Destination *int64 -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *Int64Flag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *Int64Flag) Names() []string { - return flagNames(f) -} - -// Int64 looks up the value of a local Int64Flag, returns -// 0 if not found -func (c *Context) Int64(name string) int64 { - if fs := lookupFlagSet(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value int - DefaultText string - - Destination *int -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *IntFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *IntFlag) Names() []string { - return flagNames(f) -} - -// Int looks up the value of a local IntFlag, returns -// 0 if not found -func (c *Context) Int(name string) int { - if fs := lookupFlagSet(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value *IntSlice - DefaultText string -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *IntSliceFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *IntSliceFlag) Names() []string { - return flagNames(f) -} - -// IntSlice looks up the value of a local IntSliceFlag, returns -// nil if not found -func (c *Context) IntSlice(name string) []int { - if fs := lookupFlagSet(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value *Int64Slice - DefaultText string -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *Int64SliceFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *Int64SliceFlag) Names() []string { - return flagNames(f) -} - -// Int64Slice looks up the value of a local Int64SliceFlag, returns -// nil if not found -func (c *Context) Int64Slice(name string) []int64 { - if fs := lookupFlagSet(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 -} - -// Float64SliceFlag is a flag with type *Float64Slice -type Float64SliceFlag struct { - Name string - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value *Float64Slice - DefaultText string -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *Float64SliceFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *Float64SliceFlag) Names() []string { - return flagNames(f) -} - -// Float64Slice looks up the value of a local Float64SliceFlag, returns -// nil if not found -func (c *Context) Float64Slice(name string) []float64 { - if fs := lookupFlagSet(name, c); fs != nil { - return lookupFloat64Slice(name, fs) - } - return nil -} - -func lookupFloat64Slice(name string, set *flag.FlagSet) []float64 { - f := set.Lookup(name) - if f != nil { - parsed, err := (f.Value.(*Float64Slice)).Value(), error(nil) - if err != nil { - return nil - } - return parsed - } - return nil -} - -// StringFlag is a flag with type string -type StringFlag struct { - Name string - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value string - DefaultText string - - Destination *string -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *StringFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *StringFlag) Names() []string { - return flagNames(f) -} - -// String looks up the value of a local StringFlag, returns -// "" if not found -func (c *Context) String(name string) string { - if fs := lookupFlagSet(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 "" -} - -// PathFlag is a flag with type string -type PathFlag struct { - Name string - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value string - DefaultText string - - Destination *string -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *PathFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *PathFlag) Names() []string { - return flagNames(f) -} - -// Path looks up the value of a local PathFlag, returns -// "" if not found -func (c *Context) Path(name string) string { - if fs := lookupFlagSet(name, c); fs != nil { - return lookupPath(name, fs) - } - return "" -} - -func lookupPath(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value *StringSlice - DefaultText string -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *StringSliceFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *StringSliceFlag) Names() []string { - return flagNames(f) -} - -// StringSlice looks up the value of a local StringSliceFlag, returns -// nil if not found -func (c *Context) StringSlice(name string) []string { - if fs := lookupFlagSet(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value uint64 - DefaultText string - - Destination *uint64 -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *Uint64Flag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *Uint64Flag) Names() []string { - return flagNames(f) -} - -// Uint64 looks up the value of a local Uint64Flag, returns -// 0 if not found -func (c *Context) Uint64(name string) uint64 { - if fs := lookupFlagSet(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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value uint - DefaultText string - - Destination *uint -} - -// String returns a readable representation of this value -// (for usage defaults) -func (f *UintFlag) String() string { - return FlagStringer(f) -} - -// Names returns the names of the flag -func (f *UintFlag) Names() []string { - return flagNames(f) -} - -// Uint looks up the value of a local UintFlag, returns -// 0 if not found -func (c *Context) Uint(name string) uint { - if fs := lookupFlagSet(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 -} diff --git a/flag_generic.go b/flag_generic.go new file mode 100644 index 0000000..169c364 --- /dev/null +++ b/flag_generic.go @@ -0,0 +1,104 @@ +package cli + +import ( + "flag" + "fmt" +) + +// Generic is a generic parseable type identified by a specific flag +type Generic interface { + Set(value string) error + String() string +} + +// GenericFlag is a flag with type Generic +type GenericFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + TakesFile bool + Value Generic + DefaultText string +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *GenericFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *GenericFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *GenericFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *GenericFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *GenericFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *GenericFlag) GetValue() string { + if f.Value != nil { + return f.Value.String() + } + return "" +} + +// Apply 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) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + if err := f.Value.Set(val); err != nil { + return fmt.Errorf("could not parse %s as value for flag %s: %s", val, f.Name, err) + } + } + + for _, name := range f.Names() { + set.Var(f.Value, name, f.Usage) + } + + return nil +} + +// 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 +} diff --git a/flag_int.go b/flag_int.go new file mode 100644 index 0000000..f026650 --- /dev/null +++ b/flag_int.go @@ -0,0 +1,103 @@ +package cli + +import ( + "flag" + "fmt" + "strconv" +) + +// IntFlag is a flag with type int +type IntFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value int + DefaultText string + Destination *int +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *IntFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *IntFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *IntFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *IntFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *IntFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *IntFlag) GetValue() string { + return fmt.Sprintf("%d", f.Value) +} + +// Apply populates the flag given the flag set and environment +func (f *IntFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + if val != "" { + valInt, err := strconv.ParseInt(val, 0, 64) + if err != nil { + return fmt.Errorf("could not parse %s as int value for flag %s: %s", val, f.Name, err) + } + f.Value = int(valInt) + } + } + + for _, name := range f.Names() { + if f.Destination != nil { + set.IntVar(f.Destination, name, f.Value, f.Usage) + continue + } + set.Int(name, f.Value, f.Usage) + } + + return nil +} + +// 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 +} diff --git a/flag_int64.go b/flag_int64.go new file mode 100644 index 0000000..60ef026 --- /dev/null +++ b/flag_int64.go @@ -0,0 +1,103 @@ +package cli + +import ( + "flag" + "fmt" + "strconv" +) + +// Int64Flag is a flag with type int64 +type Int64Flag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value int64 + DefaultText string + Destination *int64 +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *Int64Flag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *Int64Flag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *Int64Flag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *Int64Flag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *Int64Flag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *Int64Flag) GetValue() string { + return fmt.Sprintf("%d", f.Value) +} + +// Apply populates the flag given the flag set and environment +func (f *Int64Flag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + if val != "" { + valInt, err := strconv.ParseInt(val, 0, 64) + if err != nil { + return fmt.Errorf("could not parse %s as int value for flag %s: %s", val, f.Name, err) + } + f.Value = valInt + } + } + + for _, name := range f.Names() { + if f.Destination != nil { + set.Int64Var(f.Destination, name, f.Value, f.Usage) + continue + } + set.Int64(name, f.Value, f.Usage) + } + + return nil +} + +// 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 +} diff --git a/flag_int64_slice.go b/flag_int64_slice.go new file mode 100644 index 0000000..2c82329 --- /dev/null +++ b/flag_int64_slice.go @@ -0,0 +1,164 @@ +package cli + +import ( + "encoding/json" + "flag" + "fmt" + "strconv" + "strings" +) + +// Int64Slice wraps []int64 to satisfy flag.Value +type Int64Slice struct { + slice []int64 + hasBeenSet bool +} + +// NewInt64Slice makes an *Int64Slice with default values +func NewInt64Slice(defaults ...int64) *Int64Slice { + return &Int64Slice{slice: append([]int64{}, defaults...)} +} + +// Set parses the value into an integer and appends it to the list of values +func (i *Int64Slice) Set(value string) error { + if !i.hasBeenSet { + i.slice = []int64{} + i.hasBeenSet = true + } + + if strings.HasPrefix(value, slPfx) { + // Deserializing assumes overwrite + _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &i.slice) + i.hasBeenSet = true + return nil + } + + tmp, err := strconv.ParseInt(value, 0, 64) + if err != nil { + return err + } + + i.slice = append(i.slice, tmp) + return nil +} + +// String returns a readable representation of this value (for usage defaults) +func (i *Int64Slice) String() string { + return fmt.Sprintf("%#v", i.slice) +} + +// Serialize allows Int64Slice to fulfill Serializer +func (i *Int64Slice) Serialize() string { + jsonBytes, _ := json.Marshal(i.slice) + return fmt.Sprintf("%s%s", slPfx, string(jsonBytes)) +} + +// Value returns the slice of ints set by this flag +func (i *Int64Slice) Value() []int64 { + return i.slice +} + +// Get returns the slice of ints set by this flag +func (i *Int64Slice) Get() interface{} { + return *i +} + +// Int64SliceFlag is a flag with type *Int64Slice +type Int64SliceFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value *Int64Slice + DefaultText string +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *Int64SliceFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *Int64SliceFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *Int64SliceFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *Int64SliceFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f Int64SliceFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *Int64SliceFlag) GetValue() string { + if f.Value != nil { + return f.Value.String() + } + return "" +} + +// Apply populates the flag given the flag set and environment +func (f *Int64SliceFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + f.Value = &Int64Slice{} + + for _, s := range strings.Split(val, ",") { + if err := f.Value.Set(strings.TrimSpace(s)); err != nil { + return fmt.Errorf("could not parse %s as int64 slice value for flag %s: %s", f.Value, f.Name, err) + } + } + } + + for _, name := range f.Names() { + if f.Value == nil { + f.Value = &Int64Slice{} + } + set.Var(f.Value, name, f.Usage) + } + + return nil +} + +// Int64Slice looks up the value of a local Int64SliceFlag, returns +// nil if not found +func (c *Context) Int64Slice(name string) []int64 { + if fs := lookupFlagSet(name, c); fs != nil { + return lookupInt64Slice(name, fs) + } + return nil +} + +// GlobalInt64Slice looks up the value of a global Int64SliceFlag, returns +// nil if not found +//func (c *Context) GlobalInt64Slice(name string) []int { +// 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 +} diff --git a/flag_int_slice.go b/flag_int_slice.go new file mode 100644 index 0000000..c885dd3 --- /dev/null +++ b/flag_int_slice.go @@ -0,0 +1,175 @@ +package cli + +import ( + "encoding/json" + "flag" + "fmt" + "strconv" + "strings" +) + +// IntSlice wraps []int to satisfy flag.Value +type IntSlice struct { + slice []int + hasBeenSet bool +} + +// NewIntSlice makes an *IntSlice with default values +func NewIntSlice(defaults ...int) *IntSlice { + return &IntSlice{slice: append([]int{}, defaults...)} +} + +// TODO: Consistently have specific Set function for Int64 and Float64 ? +// SetInt directly adds an integer to the list of values +func (i *IntSlice) SetInt(value int) { + if !i.hasBeenSet { + i.slice = []int{} + i.hasBeenSet = true + } + + i.slice = append(i.slice, value) +} + +// Set parses the value into an integer and appends it to the list of values +func (i *IntSlice) Set(value string) error { + if !i.hasBeenSet { + i.slice = []int{} + i.hasBeenSet = true + } + + if strings.HasPrefix(value, slPfx) { + // Deserializing assumes overwrite + _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &i.slice) + i.hasBeenSet = true + return nil + } + + tmp, err := strconv.ParseInt(value, 0, 64) + if err != nil { + return err + } + + i.slice = append(i.slice, int(tmp)) + return nil +} + +// String returns a readable representation of this value (for usage defaults) +func (i *IntSlice) String() string { + return fmt.Sprintf("%#v", i.slice) +} + +// Serialize allows IntSlice to fulfill Serializer +func (i *IntSlice) Serialize() string { + jsonBytes, _ := json.Marshal(i.slice) + return fmt.Sprintf("%s%s", slPfx, string(jsonBytes)) +} + +// Value returns the slice of ints set by this flag +func (i *IntSlice) Value() []int { + return i.slice +} + +// Get returns the slice of ints set by this flag +func (i *IntSlice) Get() interface{} { + return *i +} + +// IntSliceFlag is a flag with type *IntSlice +type IntSliceFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value *IntSlice + DefaultText string +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *IntSliceFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *IntSliceFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *IntSliceFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *IntSliceFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f IntSliceFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *IntSliceFlag) GetValue() string { + if f.Value != nil { + return f.Value.String() + } + return "" +} + +// Apply populates the flag given the flag set and environment +func (f *IntSliceFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + f.Value = &IntSlice{} + + for _, s := range strings.Split(val, ",") { + if err := f.Value.Set(strings.TrimSpace(s)); err != nil { + return fmt.Errorf("could not parse %s as int slice value for flag %s: %s", val, f.Name, err) + } + } + } + + for _, name := range f.Names() { + if f.Value == nil { + f.Value = &IntSlice{} + } + set.Var(f.Value, name, f.Usage) + } + + return nil +} + +// IntSlice looks up the value of a local IntSliceFlag, returns +// nil if not found +func (c *Context) IntSlice(name string) []int { + if fs := lookupFlagSet(name, c); fs != nil { + return lookupIntSlice(name, c.flagSet) + } + return nil +} + +// 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 +} diff --git a/flag_path.go b/flag_path.go new file mode 100644 index 0000000..0e7fd01 --- /dev/null +++ b/flag_path.go @@ -0,0 +1,85 @@ +package cli + +import "flag" + +type PathFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + EnvVar string + FilePath string + Required bool + Hidden bool + TakesFile bool + Value string + DefaultText string + Destination *string +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *PathFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *PathFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *PathFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *PathFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *PathFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *PathFlag) GetValue() string { + return f.Value +} + +// Apply populates the flag given the flag set and environment +func (f *PathFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + f.Value = val + } + + for _, name := range f.Names() { + if f.Destination != nil { + set.StringVar(f.Destination, name, f.Value, f.Usage) + return + } + set.String(name, f.Value, f.Usage) + } + + return nil +} + +// String looks up the value of a local PathFlag, returns +// "" if not found +func (c *Context) Path(name string) string { + return lookupPath(name, c.flagSet) +} + +func lookupPath(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 "" +} diff --git a/flag_string.go b/flag_string.go new file mode 100644 index 0000000..fccc670 --- /dev/null +++ b/flag_string.go @@ -0,0 +1,95 @@ +package cli + +import "flag" + +// StringFlag is a flag with type string +type StringFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + EnvVar string + FilePath string + Required bool + Hidden bool + TakesFile bool + Value string + DefaultText string + Destination *string +} + +// String returns a readable representation of this value +// (for usage defaults) +func (s *StringFlag) String() string { + return FlagStringer(s) +} + +// Names returns the names of the flag +func (s *StringFlag) Names() []string { + return flagNames(s) +} + +// IsRequired returns whether or not the flag is required +func (s *StringFlag) IsRequired() bool { + return s.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (s *StringFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (s *StringFlag) GetUsage() string { + return s.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (s *StringFlag) GetValue() string { + return s.Value +} + +// Apply populates the flag given the flag set and environment +func (s *StringFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(s.EnvVars, s.FilePath); ok { + s.Value = val + } + + for _, name := range s.Names() { + if s.Destination != nil { + set.StringVar(s.Destination, name, s.Value, s.Usage) + return + } + set.String(name, s.Value, s.Usage) + } + + return nil +} + +// 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 lookupPath(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 "" +} diff --git a/flag_string_slice.go b/flag_string_slice.go new file mode 100644 index 0000000..604fab4 --- /dev/null +++ b/flag_string_slice.go @@ -0,0 +1,155 @@ +package cli + +import ( + "encoding/json" + "flag" + "fmt" + "strings" +) + +// StringSlice wraps a []string to satisfy flag.Value +type StringSlice struct { + slice []string + hasBeenSet bool +} + +// NewStringSlice creates a *StringSlice with default values +func NewStringSlice(defaults ...string) *StringSlice { + return &StringSlice{slice: append([]string{}, defaults...)} +} + +// Set appends the string value to the list of values +func (s *StringSlice) Set(value string) error { + if !s.hasBeenSet { + s.slice = []string{} + s.hasBeenSet = true + } + + if strings.HasPrefix(value, slPfx) { + // Deserializing assumes overwrite + _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &s.slice) + s.hasBeenSet = true + return nil + } + + s.slice = append(s.slice, value) + return nil +} + +// String returns a readable representation of this value (for usage defaults) +func (s *StringSlice) String() string { + return fmt.Sprintf("%s", s.slice) +} + +// Serialize allows StringSlice to fulfill Serializer +func (s *StringSlice) Serialize() string { + jsonBytes, _ := json.Marshal(s.slice) + return fmt.Sprintf("%s%s", slPfx, string(jsonBytes)) +} + +// Value returns the slice of strings set by this flag +func (s *StringSlice) Value() []string { + return s.slice +} + +// Get returns the slice of strings set by this flag +func (s *StringSlice) Get() interface{} { + return *s +} + +// StringSliceFlag is a flag with type *StringSlice +type StringSliceFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + TakesFile bool + Value *StringSlice + DefaultText string +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *StringSliceFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *StringSliceFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *StringSliceFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *StringSliceFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *StringSliceFlag) GetUsage() string { + return f.Usage +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *StringSliceFlag) GetValue() string { + if f.Value != nil { + return f.Value.String() + } + return "" +} + +// Apply populates the flag given the flag set and environment +func (f *StringSliceFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + f.Value = &StringSlice{} + for _, s := range strings.Split(val, ",") { + if err := f.Value.Set(strings.TrimSpace(s)); err != nil { + return fmt.Errorf("could not parse %s as string value for flag %s: %s", val, f.Name, err) + } + } + } + + for _, name := range f.Names() { + if f.Value == nil { + f.Value = &StringSlice{} + } + set.Var(f.Value, name, f.Usage) + } + + return nil +} + +// 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 +} diff --git a/flag_test.go b/flag_test.go index 6ed3a76..d097776 100644 --- a/flag_test.go +++ b/flag_test.go @@ -3,6 +3,8 @@ package cli import ( "flag" "fmt" + "io" + "io/ioutil" "os" "reflect" "regexp" @@ -111,10 +113,16 @@ func TestFlagsFromEnv(t *testing.T) { {"foo,bar", &Parser{"foo", "bar"}, &GenericFlag{Name: "names", Value: &Parser{}, EnvVars: []string{"NAMES"}}, ""}, } +//<<<<<<< HEAD +// for i, test := range flagTests { +// os.Clearenv() +// envVarSlice := reflect.Indirect(reflect.ValueOf(test.flag)).FieldByName("EnvVars").Slice(0, 1) +// os.Setenv(envVarSlice.Index(0).String(), test.input) +//======= for i, test := range flagTests { - clearenv() - envVarSlice := reflect.Indirect(reflect.ValueOf(test.flag)).FieldByName("EnvVars").Slice(0, 1) - os.Setenv(envVarSlice.Index(0).String(), test.input) + os.Clearenv() + _ = os.Setenv(reflect.ValueOf(test.flag).FieldByName("EnvVar").String(), test.input) +//>>>>>>> master a := App{ Flags: []Flag{test.flag}, Action: func(ctx *Context) error { @@ -180,8 +188,10 @@ func TestStringFlagDefaultText(t *testing.T) { } func TestStringFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_FOO", "derp") + + os.Clearenv() + _ = os.Setenv("APP_FOO", "derp") + for _, test := range stringFlagTests { flag := &StringFlag{Name: test.name, Aliases: test.aliases, Value: test.value, EnvVars: []string{"APP_FOO"}} output := flag.String() @@ -196,6 +206,48 @@ func TestStringFlagWithEnvVarHelpOutput(t *testing.T) { } } +var prefixStringFlagTests = []struct { + name string + usage string + value string + prefixer FlagNamePrefixFunc + expected string +}{ + {"foo", "", "", func(a, b string) string { + return fmt.Sprintf("name: %s, ph: %s", a, b) + }, "name: foo, ph: value\t"}, + {"f", "", "", func(a, b string) string { + return fmt.Sprintf("name: %s, ph: %s", a, b) + }, "name: f, ph: value\t"}, + {"f", "The total `foo` desired", "all", func(a, b string) string { + return fmt.Sprintf("name: %s, ph: %s", a, b) + }, "name: f, ph: foo\tThe total foo desired (default: \"all\")"}, + {"test", "", "Something", func(a, b string) string { + return fmt.Sprintf("name: %s, ph: %s", a, b) + }, "name: test, ph: value\t(default: \"Something\")"}, + {"config,c", "Load configuration from `FILE`", "", func(a, b string) string { + return fmt.Sprintf("name: %s, ph: %s", a, b) + }, "name: config,c, ph: FILE\tLoad configuration from FILE"}, + {"config,c", "Load configuration from `CONFIG`", "config.json", func(a, b string) string { + return fmt.Sprintf("name: %s, ph: %s", a, b) + }, "name: config,c, ph: CONFIG\tLoad configuration from CONFIG (default: \"config.json\")"}, +} + +func TestFlagNamePrefixer(t *testing.T) { + defer func() { + FlagNamePrefixer = prefixedNames + }() + + for _, test := range prefixStringFlagTests { + FlagNamePrefixer = test.prefixer + flag := StringFlag{Name: test.name, Usage: test.usage, Value: test.value} + output := flag.String() + if output != test.expected { + t.Errorf("%q does not match %q", output, test.expected) + } + } +} + func TestStringFlagApply_SetsAllNames(t *testing.T) { v := "mmm" fl := StringFlag{Name: "hay", Aliases: []string{"H", "hayyy"}, Destination: &v} @@ -223,6 +275,7 @@ func TestPathFlagHelpOutput(t *testing.T) { flag := &PathFlag{Name: test.name, Aliases: test.aliases, Usage: test.usage, Value: test.value} output := flag.String() + if output != test.expected { t.Errorf("%q does not match %q", output, test.expected) } @@ -230,7 +283,7 @@ func TestPathFlagHelpOutput(t *testing.T) { } func TestPathFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() + os.Clearenv() os.Setenv("APP_PATH", "/path/to/file") for _, test := range pathFlagTests { flag := &PathFlag{Name: test.name, Aliases: test.aliases, Value: test.value, EnvVars: []string{"APP_PATH"}} @@ -257,17 +310,54 @@ func TestPathFlagApply_SetsAllNames(t *testing.T) { expect(t, v, "/path/to/file/PATH") } +var envHintFlagTests = []struct { + name string + env string + hinter FlagEnvHintFunc + expected string +}{ + {"foo", "", func(a, b string) string { + return fmt.Sprintf("env: %s, str: %s", a, b) + }, "env: , str: --foo value\t"}, + {"f", "", func(a, b string) string { + return fmt.Sprintf("env: %s, str: %s", a, b) + }, "env: , str: -f value\t"}, + {"foo", "ENV_VAR", func(a, b string) string { + return fmt.Sprintf("env: %s, str: %s", a, b) + }, "env: ENV_VAR, str: --foo value\t"}, + {"f", "ENV_VAR", func(a, b string) string { + return fmt.Sprintf("env: %s, str: %s", a, b) + }, "env: ENV_VAR, str: -f value\t"}, +} + +func TestFlagEnvHinter(t *testing.T) { + defer func() { + FlagEnvHinter = withEnvHint + }() + + for _, test := range envHintFlagTests { + FlagEnvHinter = test.hinter + flag := StringFlag{Name: test.name, EnvVar: test.env} + output := flag.String() + if output != test.expected { + t.Errorf("%q does not match %q", output, test.expected) + } + } +} + var stringSliceFlagTests = []struct { name string aliases []string value *StringSlice expected string }{ + {"foo", nil, NewStringSlice(""), "--foo value\t"}, {"f", nil, NewStringSlice(""), "-f value\t"}, {"f", nil, NewStringSlice("Lipstick"), "-f value\t(default: \"Lipstick\")"}, {"test", nil, NewStringSlice("Something"), "--test value\t(default: \"Something\")"}, {"dee", []string{"d"}, NewStringSlice("Inka", "Dinka", "dooo"), "--dee value, -d value\t(default: \"Inka\", \"Dinka\", \"dooo\")"}, + } func TestStringSliceFlagHelpOutput(t *testing.T) { @@ -282,8 +372,9 @@ func TestStringSliceFlagHelpOutput(t *testing.T) { } func TestStringSliceFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_QWWX", "11,4") + os.Clearenv() + _ = os.Setenv("APP_QWWX", "11,4") + for _, test := range stringSliceFlagTests { flag := &StringSliceFlag{Name: test.name, Aliases: test.aliases, Value: test.value, EnvVars: []string{"APP_QWWX"}} output := flag.String() @@ -327,8 +418,10 @@ func TestIntFlagHelpOutput(t *testing.T) { } func TestIntFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() + os.Clearenv() os.Setenv("APP_BAR", "2") + _ = os.Setenv("APP_BAR", "2") + for _, test := range intFlagTests { flag := &IntFlag{Name: test.name, EnvVars: []string{"APP_BAR"}} output := flag.String() @@ -374,8 +467,9 @@ func TestInt64FlagHelpOutput(t *testing.T) { } func TestInt64FlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_BAR", "2") + os.Clearenv() + _ = os.Setenv("APP_BAR", "2") + for _, test := range int64FlagTests { flag := IntFlag{Name: test.name, EnvVars: []string{"APP_BAR"}} output := flag.String() @@ -410,8 +504,9 @@ func TestUintFlagHelpOutput(t *testing.T) { } func TestUintFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_BAR", "2") + os.Clearenv() + _ = os.Setenv("APP_BAR", "2") + for _, test := range uintFlagTests { flag := UintFlag{Name: test.name, EnvVars: []string{"APP_BAR"}} output := flag.String() @@ -446,8 +541,9 @@ func TestUint64FlagHelpOutput(t *testing.T) { } func TestUint64FlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_BAR", "2") + os.Clearenv() + _ = os.Setenv("APP_BAR", "2") + for _, test := range uint64FlagTests { flag := UintFlag{Name: test.name, EnvVars: []string{"APP_BAR"}} output := flag.String() @@ -482,8 +578,9 @@ func TestDurationFlagHelpOutput(t *testing.T) { } func TestDurationFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_BAR", "2h3m6s") + os.Clearenv() + _ = os.Setenv("APP_BAR", "2h3m6s") + for _, test := range durationFlagTests { flag := &DurationFlag{Name: test.name, EnvVars: []string{"APP_BAR"}} output := flag.String() @@ -532,8 +629,9 @@ func TestIntSliceFlagHelpOutput(t *testing.T) { } func TestIntSliceFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_SMURF", "42,3") + os.Clearenv() + _ = os.Setenv("APP_SMURF", "42,3") + for _, test := range intSliceFlagTests { flag := &IntSliceFlag{Name: test.name, Aliases: test.aliases, Value: test.value, EnvVars: []string{"APP_SMURF"}} output := flag.String() @@ -581,8 +679,9 @@ func TestInt64SliceFlagHelpOutput(t *testing.T) { } func TestInt64SliceFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_SMURF", "42,17179869184") + os.Clearenv() + _ = os.Setenv("APP_SMURF", "42,17179869184") + for _, test := range int64SliceFlagTests { flag := Int64SliceFlag{Name: test.name, Value: test.value, EnvVars: []string{"APP_SMURF"}} output := flag.String() @@ -607,8 +706,8 @@ var float64FlagTests = []struct { func TestFloat64FlagHelpOutput(t *testing.T) { for _, test := range float64FlagTests { - flag := &Float64Flag{Name: test.name, Value: float64(0.1)} - output := flag.String() + f := &Float64Flag{Name: test.name, Value: 0.1} + output := f.String() if output != test.expected { t.Errorf("%q does not match %q", output, test.expected) @@ -617,8 +716,9 @@ func TestFloat64FlagHelpOutput(t *testing.T) { } func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_BAZ", "99.4") + os.Clearenv() + _ = os.Setenv("APP_BAZ", "99.4") + for _, test := range float64FlagTests { flag := &Float64Flag{Name: test.name, EnvVars: []string{"APP_BAZ"}} output := flag.String() @@ -634,7 +734,7 @@ func TestFloat64FlagWithEnvVarHelpOutput(t *testing.T) { } func TestFloat64FlagApply_SetsAllNames(t *testing.T) { - v := float64(99.1) + v := 99.1 fl := Float64Flag{Name: "noodles", Aliases: []string{"N", "nurbles"}, Destination: &v} set := flag.NewFlagSet("test", 0) fl.Apply(set) @@ -668,7 +768,7 @@ func TestFloat64SliceFlagHelpOutput(t *testing.T) { } func TestFloat64SliceFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() + os.Clearenv() os.Setenv("APP_SMURF", "0.1234,-10.5") for _, test := range float64SliceFlagTests { flag := Float64SliceFlag{Name: test.name, Value: test.value, EnvVars: []string{"APP_SMURF"}} @@ -705,8 +805,9 @@ func TestGenericFlagHelpOutput(t *testing.T) { } func TestGenericFlagWithEnvVarHelpOutput(t *testing.T) { - clearenv() - os.Setenv("APP_ZAP", "3") + os.Clearenv() + _ = os.Setenv("APP_ZAP", "3") + for _, test := range genericFlagTests { flag := &GenericFlag{Name: test.name, EnvVars: []string{"APP_ZAP"}} output := flag.String() @@ -731,7 +832,7 @@ func TestGenericFlagApply_SetsAllNames(t *testing.T) { } func TestParseMultiString(t *testing.T) { - (&App{ + _ = (&App{ Flags: []Flag{ &StringFlag{Name: "serve", Aliases: []string{"s"}}, }, @@ -749,7 +850,7 @@ func TestParseMultiString(t *testing.T) { func TestParseDestinationString(t *testing.T) { var dest string - a := App{ + _ = (&App{ Flags: []Flag{ &StringFlag{ Name: "dest", @@ -762,14 +863,13 @@ func TestParseDestinationString(t *testing.T) { } return nil }, - } - a.Run([]string{"run", "--dest", "10"}) + }).Run([]string{"run", "--dest", "10"}) } func TestParseMultiStringFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_COUNT", "20") - (&App{ + os.Clearenv() + _ = os.Setenv("APP_COUNT", "20") + _ = (&App{ Flags: []Flag{ &StringFlag{Name: "count", Aliases: []string{"c"}, EnvVars: []string{"APP_COUNT"}}, }, @@ -786,9 +886,9 @@ func TestParseMultiStringFromEnv(t *testing.T) { } func TestParseMultiStringFromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_COUNT", "20") - (&App{ + os.Clearenv() + _ = os.Setenv("APP_COUNT", "20") + _ = (&App{ Flags: []Flag{ &StringFlag{Name: "count", Aliases: []string{"c"}, EnvVars: []string{"COMPAT_COUNT", "APP_COUNT"}}, }, @@ -805,7 +905,7 @@ func TestParseMultiStringFromEnvCascade(t *testing.T) { } func TestParseMultiStringSlice(t *testing.T) { - (&App{ + _ = (&App{ Flags: []Flag{ &StringSliceFlag{Name: "serve", Aliases: []string{"s"}, Value: NewStringSlice()}, }, @@ -823,7 +923,7 @@ func TestParseMultiStringSlice(t *testing.T) { } func TestParseMultiStringSliceWithDefaults(t *testing.T) { - (&App{ + _ = (&App{ Flags: []Flag{ &StringSliceFlag{Name: "serve", Aliases: []string{"s"}, Value: NewStringSlice("9", "2")}, }, @@ -841,7 +941,7 @@ func TestParseMultiStringSliceWithDefaults(t *testing.T) { } func TestParseMultiStringSliceWithDefaultsUnset(t *testing.T) { - (&App{ + _ = (&App{ Flags: []Flag{ &StringSliceFlag{Name: "serve", Aliases: []string{"s"}, Value: NewStringSlice("9", "2")}, }, @@ -858,10 +958,10 @@ func TestParseMultiStringSliceWithDefaultsUnset(t *testing.T) { } func TestParseMultiStringSliceFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,40") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,40") - (&App{ + _ = (&App{ Flags: []Flag{ &StringSliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewStringSlice(), EnvVars: []string{"APP_INTERVALS"}}, }, @@ -878,10 +978,10 @@ func TestParseMultiStringSliceFromEnv(t *testing.T) { } func TestParseMultiStringSliceFromEnvWithDefaults(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,40") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,40") - (&App{ + _ = (&App{ Flags: []Flag{ &StringSliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewStringSlice("1", "2", "5"), EnvVars: []string{"APP_INTERVALS"}}, }, @@ -898,10 +998,10 @@ func TestParseMultiStringSliceFromEnvWithDefaults(t *testing.T) { } func TestParseMultiStringSliceFromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,40") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,40") - (&App{ + _ = (&App{ Flags: []Flag{ &StringSliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewStringSlice(), EnvVars: []string{"COMPAT_INTERVALS", "APP_INTERVALS"}}, }, @@ -918,10 +1018,10 @@ func TestParseMultiStringSliceFromEnvCascade(t *testing.T) { } func TestParseMultiStringSliceFromEnvCascadeWithDefaults(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,40") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,40") - (&App{ + _ = (&App{ Flags: []Flag{ &StringSliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewStringSlice("1", "2", "5"), EnvVars: []string{"COMPAT_INTERVALS", "APP_INTERVALS"}}, }, @@ -938,7 +1038,7 @@ func TestParseMultiStringSliceFromEnvCascadeWithDefaults(t *testing.T) { } func TestParseMultiInt(t *testing.T) { - a := App{ + _ = (&App{ Flags: []Flag{ &IntFlag{Name: "serve", Aliases: []string{"s"}}, }, @@ -951,13 +1051,12 @@ func TestParseMultiInt(t *testing.T) { } return nil }, - } - a.Run([]string{"run", "-s", "10"}) + }).Run([]string{"run", "-s", "10"}) } func TestParseDestinationInt(t *testing.T) { var dest int - a := App{ + _ = (&App{ Flags: []Flag{ &IntFlag{ Name: "dest", @@ -970,14 +1069,13 @@ func TestParseDestinationInt(t *testing.T) { } return nil }, - } - a.Run([]string{"run", "--dest", "10"}) + }).Run([]string{"run", "--dest", "10"}) } func TestParseMultiIntFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_TIMEOUT_SECONDS", "10") - a := App{ + os.Clearenv() + _ = os.Setenv("APP_TIMEOUT_SECONDS", "10") + _ = (&App{ Flags: []Flag{ &IntFlag{Name: "timeout", Aliases: []string{"t"}, EnvVars: []string{"APP_TIMEOUT_SECONDS"}}, }, @@ -990,14 +1088,13 @@ func TestParseMultiIntFromEnv(t *testing.T) { } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } func TestParseMultiIntFromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_TIMEOUT_SECONDS", "10") - a := App{ + os.Clearenv() + _ = os.Setenv("APP_TIMEOUT_SECONDS", "10") + _ = (&App{ Flags: []Flag{ &IntFlag{Name: "timeout", Aliases: []string{"t"}, EnvVars: []string{"COMPAT_TIMEOUT_SECONDS", "APP_TIMEOUT_SECONDS"}}, }, @@ -1010,12 +1107,11 @@ func TestParseMultiIntFromEnvCascade(t *testing.T) { } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } func TestParseMultiIntSlice(t *testing.T) { - (&App{ + _ = (&App{ Flags: []Flag{ &IntSliceFlag{Name: "serve", Aliases: []string{"s"}, Value: NewIntSlice()}, }, @@ -1032,7 +1128,7 @@ func TestParseMultiIntSlice(t *testing.T) { } func TestParseMultiIntSliceWithDefaults(t *testing.T) { - (&App{ + _ = (&App{ Flags: []Flag{ &IntSliceFlag{Name: "serve", Aliases: []string{"s"}, Value: NewIntSlice(9, 2)}, }, @@ -1049,7 +1145,7 @@ func TestParseMultiIntSliceWithDefaults(t *testing.T) { } func TestParseMultiIntSliceWithDefaultsUnset(t *testing.T) { - (&App{ + _ = (&App{ Flags: []Flag{ &IntSliceFlag{Name: "serve", Aliases: []string{"s"}, Value: NewIntSlice(9, 2)}, }, @@ -1066,10 +1162,10 @@ func TestParseMultiIntSliceWithDefaultsUnset(t *testing.T) { } func TestParseMultiIntSliceFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,40") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,40") - (&App{ + _ = (&App{ Flags: []Flag{ &IntSliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewIntSlice(), EnvVars: []string{"APP_INTERVALS"}}, }, @@ -1086,10 +1182,10 @@ func TestParseMultiIntSliceFromEnv(t *testing.T) { } func TestParseMultiIntSliceFromEnvWithDefaults(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,40") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,40") - (&App{ + _ = (&App{ Flags: []Flag{ &IntSliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewIntSlice(1, 2, 5), EnvVars: []string{"APP_INTERVALS"}}, }, @@ -1106,10 +1202,10 @@ func TestParseMultiIntSliceFromEnvWithDefaults(t *testing.T) { } func TestParseMultiIntSliceFromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,40") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,40") - (&App{ + _ = (&App{ Flags: []Flag{ &IntSliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewIntSlice(), EnvVars: []string{"COMPAT_INTERVALS", "APP_INTERVALS"}}, }, @@ -1126,7 +1222,7 @@ func TestParseMultiIntSliceFromEnvCascade(t *testing.T) { } func TestParseMultiInt64Slice(t *testing.T) { - (&App{ + _ = (&App{ Flags: []Flag{ &Int64SliceFlag{Name: "serve", Aliases: []string{"s"}, Value: NewInt64Slice()}, }, @@ -1143,10 +1239,10 @@ func TestParseMultiInt64Slice(t *testing.T) { } func TestParseMultiInt64SliceFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,17179869184") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,17179869184") - (&App{ + _ = (&App{ Flags: []Flag{ &Int64SliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewInt64Slice(), EnvVars: []string{"APP_INTERVALS"}}, }, @@ -1163,10 +1259,10 @@ func TestParseMultiInt64SliceFromEnv(t *testing.T) { } func TestParseMultiInt64SliceFromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "20,30,17179869184") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "20,30,17179869184") - (&App{ + _ = (&App{ Flags: []Flag{ &Int64SliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewInt64Slice(), EnvVars: []string{"COMPAT_INTERVALS", "APP_INTERVALS"}}, }, @@ -1183,7 +1279,7 @@ func TestParseMultiInt64SliceFromEnvCascade(t *testing.T) { } func TestParseMultiFloat64(t *testing.T) { - a := App{ + _ = (&App{ Flags: []Flag{ &Float64Flag{Name: "serve", Aliases: []string{"s"}}, }, @@ -1196,13 +1292,12 @@ func TestParseMultiFloat64(t *testing.T) { } return nil }, - } - a.Run([]string{"run", "-s", "10.2"}) + }).Run([]string{"run", "-s", "10.2"}) } func TestParseDestinationFloat64(t *testing.T) { var dest float64 - a := App{ + _ = (&App{ Flags: []Flag{ &Float64Flag{ Name: "dest", @@ -1215,14 +1310,13 @@ func TestParseDestinationFloat64(t *testing.T) { } return nil }, - } - a.Run([]string{"run", "--dest", "10.2"}) + }).Run([]string{"run", "--dest", "10.2"}) } func TestParseMultiFloat64FromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_TIMEOUT_SECONDS", "15.5") - a := App{ + os.Clearenv() + _ = os.Setenv("APP_TIMEOUT_SECONDS", "15.5") + _ = (&App{ Flags: []Flag{ &Float64Flag{Name: "timeout", Aliases: []string{"t"}, EnvVars: []string{"APP_TIMEOUT_SECONDS"}}, }, @@ -1235,14 +1329,13 @@ func TestParseMultiFloat64FromEnv(t *testing.T) { } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } func TestParseMultiFloat64FromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_TIMEOUT_SECONDS", "15.5") - a := App{ + os.Clearenv() + _ = os.Setenv("APP_TIMEOUT_SECONDS", "15.5") + _ = (&App{ Flags: []Flag{ &Float64Flag{Name: "timeout", Aliases: []string{"t"}, EnvVars: []string{"COMPAT_TIMEOUT_SECONDS", "APP_TIMEOUT_SECONDS"}}, }, @@ -1255,15 +1348,14 @@ func TestParseMultiFloat64FromEnvCascade(t *testing.T) { } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } func TestParseMultiFloat64SliceFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "0.1,-10.5") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "0.1,-10.5") - (&App{ + _ = (&App{ Flags: []Flag{ &Float64SliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewFloat64Slice(), EnvVars: []string{"APP_INTERVALS"}}, }, @@ -1280,10 +1372,10 @@ func TestParseMultiFloat64SliceFromEnv(t *testing.T) { } func TestParseMultiFloat64SliceFromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_INTERVALS", "0.1234,-10.5") + os.Clearenv() + _ = os.Setenv("APP_INTERVALS", "0.1234,-10.5") - (&App{ + _ = (&App{ Flags: []Flag{ &Float64SliceFlag{Name: "intervals", Aliases: []string{"i"}, Value: NewFloat64Slice(), EnvVars: []string{"COMPAT_INTERVALS", "APP_INTERVALS"}}, }, @@ -1300,7 +1392,7 @@ func TestParseMultiFloat64SliceFromEnvCascade(t *testing.T) { } func TestParseMultiBool(t *testing.T) { - a := App{ + _ = (&App{ Flags: []Flag{ &BoolFlag{Name: "serve", Aliases: []string{"s"}}, }, @@ -1313,13 +1405,36 @@ func TestParseMultiBool(t *testing.T) { } return nil }, - } - a.Run([]string{"run", "--serve"}) + }).Run([]string{"run", "--serve"}) +} + +func TestParseBoolShortOptionHandle(t *testing.T) { + _ = (&App{ + Commands: []*Command{ + { + Name: "foobar", + UseShortOptionHandling: true, + Action: func(ctx *Context) error { + if ctx.Bool("serve") != true { + t.Errorf("main name not set") + } + if ctx.Bool("option") != true { + t.Errorf("short name not set") + } + return nil + }, + Flags: []Flag{ + BoolFlag{Name: "serve, s"}, + BoolFlag{Name: "option, o"}, + }, + }, + }, + }).Run([]string{"run", "foobar", "-so"}) } func TestParseDestinationBool(t *testing.T) { var dest bool - a := App{ + _ = (&App{ Flags: []Flag{ &BoolFlag{ Name: "dest", @@ -1332,14 +1447,13 @@ func TestParseDestinationBool(t *testing.T) { } return nil }, - } - a.Run([]string{"run", "--dest"}) + }).Run([]string{"run", "--dest"}) } func TestParseMultiBoolFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_DEBUG", "1") - a := App{ + os.Clearenv() + _ = os.Setenv("APP_DEBUG", "1") + _ = (&App{ Flags: []Flag{ &BoolFlag{Name: "debug", Aliases: []string{"d"}, EnvVars: []string{"APP_DEBUG"}}, }, @@ -1352,14 +1466,13 @@ func TestParseMultiBoolFromEnv(t *testing.T) { } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } func TestParseMultiBoolFromEnvCascade(t *testing.T) { - clearenv() + os.Clearenv() os.Setenv("APP_DEBUG", "1") - a := App{ + _ = (&App{ Flags: []Flag{ &BoolFlag{Name: "debug", Aliases: []string{"d"}, EnvVars: []string{"COMPAT_DEBUG", "APP_DEBUG"}}, }, @@ -1372,97 +1485,93 @@ func TestParseMultiBoolFromEnvCascade(t *testing.T) { } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } -func TestParseMultiBoolTrue(t *testing.T) { - a := App{ - Flags: []Flag{ - &BoolFlag{Name: "implode", Aliases: []string{"i"}, Value: true}, - }, - Action: func(ctx *Context) error { - if ctx.Bool("implode") { - t.Errorf("main name not set") - } - if ctx.Bool("i") { - t.Errorf("short name not set") - } - return nil - }, +func TestParseBoolTFromEnv(t *testing.T) { + var boolTFlagTests = []struct { + input string + output bool + }{ + {"", false}, + {"1", true}, + {"false", false}, + {"true", true}, } - a.Run([]string{"run", "--implode=false"}) -} -func TestParseDestinationBoolTrue(t *testing.T) { - dest := true - - a := App{ - Flags: []Flag{ - &BoolFlag{ - Name: "dest", - Value: true, - Destination: &dest, + for _, test := range boolTFlagTests { + os.Clearenv() + _ = os.Setenv("DEBUG", test.input) + _ = (&App{ + Flags: []Flag{ + BoolTFlag{Name: "debug, d", EnvVar: "DEBUG"}, }, - }, - Action: func(ctx *Context) error { - if dest { - t.Errorf("expected destination Bool false") - } - return nil - }, + Action: func(ctx *Context) error { + if ctx.Bool("debug") != test.output { + t.Errorf("expected %+v to be parsed as %+v, instead was %+v", test.input, test.output, ctx.Bool("debug")) + } + if ctx.Bool("d") != test.output { + t.Errorf("expected %+v to be parsed as %+v, instead was %+v", test.input, test.output, ctx.Bool("d")) + } + return nil + }, + }).Run([]string{"run"}) } - a.Run([]string{"run", "--dest=false"}) } -func TestParseMultiBoolTrueFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_DEBUG", "0") - a := App{ - Flags: []Flag{ - &BoolFlag{ - Name: "debug", - Aliases: []string{"d"}, - Value: true, - EnvVars: []string{"APP_DEBUG"}, +func TestParseMultiBoolT(t *testing.T) { + _ = (&App{ + Flags: []Flag{ + &BoolFlag{Name: "implode", Aliases: []string{"i"}, Value: true}, + }, + Action: func(ctx *Context) error { + if ctx.Bool("implode") { + t.Errorf("main name not set") + } + if ctx.Bool("i") { + t.Errorf("short name not set") + } + return nil }, + }).Run([]string{"run", "--implode=false"}) +} + +func TestParseMultiBoolTFromEnv(t *testing.T) { + os.Clearenv() + _ = os.Setenv("APP_DEBUG", "0") + _ = (&App{ + Flags: []Flag{ + &BoolTFlag{Name: "debug, d", EnvVar: "APP_DEBUG"}, }, Action: func(ctx *Context) error { - if ctx.Bool("debug") { + if ctx.BoolT("debug") != false { t.Errorf("main name not set from env") } - if ctx.Bool("d") { + if ctx.BoolT("d") != false { t.Errorf("short name not set from env") } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } -func TestParseMultiBoolTrueFromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_DEBUG", "0") - a := App{ +func TestParseMultiBoolTFromEnvCascade(t *testing.T) { + os.Clearenv() + _ = os.Setenv("APP_DEBUG", "0") + _ = (&App{ Flags: []Flag{ - &BoolFlag{ - Name: "debug", - Aliases: []string{"d"}, - Value: true, - EnvVars: []string{"COMPAT_DEBUG", "APP_DEBUG"}, - }, + &BoolTFlag{Name: "debug, d", EnvVar: "COMPAT_DEBUG,APP_DEBUG"}, }, Action: func(ctx *Context) error { - if ctx.Bool("debug") { + if ctx.BoolT("debug") != false { t.Errorf("main name not set from env") } - if ctx.Bool("d") { + if ctx.BoolT("d") != false { t.Errorf("short name not set from env") } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } type Parser [2]string @@ -1488,7 +1597,7 @@ func (p *Parser) Get() interface{} { } func TestParseGeneric(t *testing.T) { - a := App{ + _ = (&App{ Flags: []Flag{ &GenericFlag{Name: "serve", Aliases: []string{"s"}, Value: &Parser{}}, }, @@ -1501,14 +1610,14 @@ func TestParseGeneric(t *testing.T) { } return nil }, - } - a.Run([]string{"run", "-s", "10,20"}) + }).Run([]string{"run", "-s", "10,20"}) } func TestParseGenericFromEnv(t *testing.T) { - clearenv() - os.Setenv("APP_SERVE", "20,30") - a := App{ + os.Clearenv() + _ = os.Setenv("APP_SERVE", "20,30") + _ = (&App{ + Flags: []Flag{ &GenericFlag{ Name: "serve", @@ -1526,14 +1635,13 @@ func TestParseGenericFromEnv(t *testing.T) { } return nil }, - } - a.Run([]string{"run"}) + }).Run([]string{"run"}) } func TestParseGenericFromEnvCascade(t *testing.T) { - clearenv() - os.Setenv("APP_FOO", "99,2000") - a := App{ + os.Clearenv() + _ = os.Setenv("APP_FOO", "99,2000") + _ = (&App{ Flags: []Flag{ &GenericFlag{ Name: "foos", @@ -1547,13 +1655,47 @@ func TestParseGenericFromEnvCascade(t *testing.T) { } return nil }, + }).Run([]string{"run"}) +} + +func TestFlagFromFile(t *testing.T) { + os.Clearenv() + os.Setenv("APP_FOO", "123") + + temp, err := ioutil.TempFile("", "urfave_cli_test") + if err != nil { + t.Error(err) + return + } + _, _ = io.WriteString(temp, "abc") + _ = temp.Close() + defer func() { + _ = os.Remove(temp.Name()) + }() + + var filePathTests = []struct { + path string + name string + expected string + }{ + {"file-does-not-exist", "APP_BAR", ""}, + {"file-does-not-exist", "APP_FOO", "123"}, + {"file-does-not-exist", "APP_FOO,APP_BAR", "123"}, + {temp.Name(), "APP_FOO", "123"}, + {temp.Name(), "APP_BAR", "abc"}, + } + + for _, filePathTest := range filePathTests { + got, _ := flagFromEnvOrFile(filePathTest.name, filePathTest.path) + if want := filePathTest.expected; got != want { + t.Errorf("Did not expect %v - Want %v", got, want) + } } - a.Run([]string{"run"}) } func TestStringSlice_Serialized_Set(t *testing.T) { sl0 := NewStringSlice("a", "b") - ser0 := sl0.Serialized() + ser0 := sl0.Serialize() if len(ser0) < len(slPfx) { t.Fatalf("serialized shorter than expected: %q", ser0) @@ -1569,7 +1711,7 @@ func TestStringSlice_Serialized_Set(t *testing.T) { func TestIntSlice_Serialized_Set(t *testing.T) { sl0 := NewIntSlice(1, 2) - ser0 := sl0.Serialized() + ser0 := sl0.Serialize() if len(ser0) < len(slPfx) { t.Fatalf("serialized shorter than expected: %q", ser0) @@ -1585,7 +1727,7 @@ func TestIntSlice_Serialized_Set(t *testing.T) { func TestInt64Slice_Serialized_Set(t *testing.T) { sl0 := NewInt64Slice(int64(1), int64(2)) - ser0 := sl0.Serialized() + ser0 := sl0.Serialize() if len(ser0) < len(slPfx) { t.Fatalf("serialized shorter than expected: %q", ser0) diff --git a/flag_uint.go b/flag_uint.go new file mode 100644 index 0000000..7a3e943 --- /dev/null +++ b/flag_uint.go @@ -0,0 +1,104 @@ +package cli + +import ( + "flag" + "fmt" + "strconv" +) + +// UintFlag is a flag with type uint +type UintFlag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value uint + DefaultText string + Destination *uint +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *UintFlag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *UintFlag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *UintFlag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *UintFlag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *UintFlag) GetUsage() string { + return f.Usage +} + +// Apply populates the flag given the flag set and environment +func (f *UintFlag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + if val != "" { + valInt, err := strconv.ParseUint(val, 0, 64) + if err != nil { + return fmt.Errorf("could not parse %s as uint value for flag %s: %s", val, f.Name, err) + } + + f.Value = uint(valInt) + } + } + + for _, name := range f.Names() { + if f.Destination != nil { + set.UintVar(f.Destination, name, f.Value, f.Usage) + continue + } + set.Uint(name, f.Value, f.Usage) + } + + return nil +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *UintFlag) GetValue() string { + return fmt.Sprintf("%d", f.Value) +} + +// 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 +} diff --git a/flag_uint64.go b/flag_uint64.go new file mode 100644 index 0000000..65534c7 --- /dev/null +++ b/flag_uint64.go @@ -0,0 +1,104 @@ +package cli + +import ( + "flag" + "fmt" + "strconv" +) + +// Uint64Flag is a flag with type uint64 +type Uint64Flag struct { + Name string + Aliases []string + Usage string + EnvVars []string + FilePath string + Required bool + Hidden bool + Value uint64 + DefaultText string + Destination *uint64 +} + +// String returns a readable representation of this value +// (for usage defaults) +func (f *Uint64Flag) String() string { + return FlagStringer(f) +} + +// Names returns the names of the flag +func (f *Uint64Flag) Names() []string { + return flagNames(f) +} + +// IsRequired returns whether or not the flag is required +func (f *Uint64Flag) IsRequired() bool { + return f.Required +} + +// TakesValue returns true of the flag takes a value, otherwise false +func (f *Uint64Flag) TakesValue() bool { + return true +} + +// GetUsage returns the usage string for the flag +func (f *Uint64Flag) GetUsage() string { + return f.Usage +} + +// Apply populates the flag given the flag set and environment +func (f *Uint64Flag) Apply(set *flag.FlagSet) error { + if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok { + if val != "" { + valInt, err := strconv.ParseUint(val, 0, 64) + if err != nil { + return fmt.Errorf("could not parse %s as uint64 value for flag %s: %s", val, f.Name, err) + } + + f.Value = valInt + } + } + + for _, name := range f.Names() { + if f.Destination != nil { + set.Uint64Var(f.Destination, name, f.Value, f.Usage) + continue + } + set.Uint64(name, f.Value, f.Usage) + } + + return nil +} + +// GetValue returns the flags value as string representation and an empty +// string if the flag takes no value at all. +func (f *Uint64Flag) GetValue() string { + return fmt.Sprintf("%d", f.Value) +} + +// 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 +} diff --git a/funcs.go b/funcs.go index fa7d502..9ffe246 100644 --- a/funcs.go +++ b/funcs.go @@ -1,7 +1,7 @@ package cli -// ShellCompleteFunc is an action to execute when the shell completion flag is set -type ShellCompleteFunc func(*Context) +// BashCompleteFunc is an action to execute when the shell 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 @@ -23,6 +23,22 @@ type CommandNotFoundFunc func(*Context, string) // 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 []string, placeholder string) string + +// FlagEnvHintFunc is used by the default FlagStringFunc to annotate flag help +// with the environment variable details. +type FlagEnvHintFunc func(envVars []string, 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 diff --git a/generate-flag-types b/generate-flag-types deleted file mode 100755 index d77d470..0000000 --- a/generate-flag-types +++ /dev/null @@ -1,255 +0,0 @@ -#!/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 - - -_PY3 = sys.version_info.major == 3 - - -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 = _get_named_tmp_go() - 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 _get_named_tmp_go(): - tmp_args = dict(suffix='.go', mode='w', delete=False) - if _PY3: - tmp_args['encoding'] = 'utf-8' - return tempfile.NamedTemporaryFile(**tmp_args) - - -def _set_typedef_defaults(typedef): - typedef.setdefault('doctail', '') - typedef.setdefault('context_type', typedef['type']) - typedef.setdefault('dest', 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 - Aliases []string - Usage string - EnvVars []string - Hidden bool - Value {type} - DefaultText string - """.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) - }} - - // Names returns the names of the flag - func (f *{name}Flag) Names() []string {{ - return flagNames(f) - }} - - // {name} looks up the value of a local {name}Flag, returns - // {context_default} if not found - func (c *Context) {name}(name string) {context_type} {{ - if fs := lookupFlagSet(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.v2" - - // 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=None, file=outfile) - - -_WRITEFUNCS = { - 'cli': _write_cli_flag_types, - 'altsrc': _write_altsrc_flag_types -} - -if __name__ == '__main__': - sys.exit(main()) diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..c38d41c --- /dev/null +++ b/go.mod @@ -0,0 +1,9 @@ +module github.com/urfave/cli/v2 + +go 1.11 + +require ( + github.com/BurntSushi/toml v0.3.1 + github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d + gopkg.in/yaml.v2 v2.2.2 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..ef121ff --- /dev/null +++ b/go.sum @@ -0,0 +1,14 @@ +github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY= +github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q= +github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo= +github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/help.go b/help.go index 02fcf33..155654f 100644 --- a/help.go +++ b/help.go @@ -7,6 +7,7 @@ import ( "strings" "text/tabwriter" "text/template" + "unicode/utf8" ) // AppHelpTemplate is the text template for the Default help topic. @@ -89,7 +90,7 @@ var helpCommand = &Command{ return ShowCommandHelp(c, args.First()) } - ShowAppHelp(c) + _ = ShowAppHelp(c) return nil }, } @@ -129,7 +130,7 @@ 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) + _ = ShowAppHelp(c) os.Exit(exitCode) } @@ -153,19 +154,94 @@ func ShowAppHelp(c *Context) (err error) { // DefaultAppComplete prints the list of subcommands as the default app completion method func DefaultAppComplete(c *Context) { - for _, command := range c.App.Commands { + DefaultCompleteWithFlags(nil)(c) +} + +func printCommandSuggestions(commands []Command, writer io.Writer) { + for _, command := range commands { if command.Hidden { continue } - for _, name := range command.Names() { - fmt.Fprintln(c.App.Writer, name) + if os.Getenv("_CLI_ZSH_AUTOCOMPLETE_HACK") == "1" { + for _, name := range command.Names() { + _, _ = fmt.Fprintf(writer, "%s:%s\n", name, command.Usage) + } + } else { + for _, name := range command.Names() { + _, _ = fmt.Fprintf(writer, "%s\n", name) + } + } + } +} + +func cliArgContains(flagName string) bool { + for _, name := range strings.Split(flagName, ",") { + name = strings.TrimSpace(name) + count := utf8.RuneCountInString(name) + if count > 2 { + count = 2 + } + flag := fmt.Sprintf("%s%s", strings.Repeat("-", count), name) + for _, a := range os.Args { + if a == flag { + return true + } + } + } + return false +} + +func printFlagSuggestions(lastArg string, flags []Flag, writer io.Writer) { + cur := strings.TrimPrefix(lastArg, "-") + cur = strings.TrimPrefix(cur, "-") + for _, flag := range flags { + if bflag, ok := flag.(BoolFlag); ok && bflag.Hidden { + continue + } + for _, name := range strings.Split(flag.GetName(), ",") { + name = strings.TrimSpace(name) + // this will get total count utf8 letters in flag name + count := utf8.RuneCountInString(name) + if count > 2 { + count = 2 // resuse this count to generate single - or -- in flag completion + } + // if flag name has more than one utf8 letter and last argument in cli has -- prefix then + // skip flag completion for short flags example -v or -x + if strings.HasPrefix(lastArg, "--") && count == 1 { + continue + } + // match if last argument matches this flag and it is not repeated + if strings.HasPrefix(name, cur) && cur != name && !cliArgContains(flag.GetName()) { + flagCompletion := fmt.Sprintf("%s%s", strings.Repeat("-", count), name) + _, _ = fmt.Fprintln(writer, flagCompletion) + } + } + } +} + +func DefaultCompleteWithFlags(cmd *Command) func(c *Context) { + return func(c *Context) { + if len(os.Args) > 2 { + lastArg := os.Args[len(os.Args)-2] + if strings.HasPrefix(lastArg, "-") { + printFlagSuggestions(lastArg, c.App.Flags, c.App.Writer) + if cmd != nil { + printFlagSuggestions(lastArg, cmd.Flags, c.App.Writer) + } + return + } + } + if cmd != nil { + printCommandSuggestions(cmd.Subcommands, c.App.Writer) + } else { + printCommandSuggestions(c.App.Commands, c.App.Writer) } } } // ShowCommandHelpAndExit - exits with code after showing help func ShowCommandHelpAndExit(c *Context, command string, code int) { - ShowCommandHelp(c, command) + _ = ShowCommandHelp(c, command) os.Exit(code) } @@ -215,49 +291,57 @@ func ShowVersion(c *Context) { } func printVersion(c *Context) { - fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version) + _, _ = 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.ShellComplete != nil { - a.ShellComplete(c) + 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) + //TODO: Resolve +//<<<<<<< HEAD if c != nil && c.ShellComplete != nil { c.ShellComplete(ctx) +//======= +// if c != nil { +// if c.BashComplete != nil { +// c.BashComplete(ctx) +// } else { +// DefaultCompleteWithFlags(c)(ctx) +// } +//>>>>>>> master } + } 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 - } + 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)) - errDebug := os.Getenv("CLI_TEMPLATE_ERROR_DEBUG") != "" - err := t.Execute(w, data) if err != nil { - if errDebug { - fmt.Fprintf(ErrWriter, "CLI TEMPLATE ERROR: %#v\n", err) + // 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() + _ = w.Flush() } func printHelp(out io.Writer, templ string, data interface{}) { @@ -286,7 +370,7 @@ func checkHelp(c *Context) bool { func checkCommandHelp(c *Context, name string) bool { if c.Bool("h") || c.Bool("help") { - ShowCommandHelp(c, name) + _ = ShowCommandHelp(c, name) return true } @@ -295,7 +379,7 @@ func checkCommandHelp(c *Context, name string) bool { func checkSubcommandHelp(c *Context) bool { if c.Bool("h") || c.Bool("help") { - ShowSubcommandHelp(c) + _ = ShowSubcommandHelp(c) return true } diff --git a/help_test.go b/help_test.go index 375b28e..6d3a6a9 100644 --- a/help_test.go +++ b/help_test.go @@ -15,9 +15,9 @@ func Test_ShowAppHelp_NoAuthor(t *testing.T) { c := NewContext(app, nil, nil) - ShowAppHelp(c) + _ = ShowAppHelp(c) - if bytes.Index(output.Bytes(), []byte("AUTHOR(S):")) != -1 { + if bytes.Contains(output.Bytes(), []byte("AUTHOR(S):")) { t.Errorf("expected\n%snot to include %s", output.String(), "AUTHOR(S):") } } @@ -30,9 +30,9 @@ func Test_ShowAppHelp_NoVersion(t *testing.T) { c := NewContext(app, nil, nil) - ShowAppHelp(c) + _ = ShowAppHelp(c) - if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 { + if bytes.Contains(output.Bytes(), []byte("VERSION:")) { t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:") } } @@ -45,9 +45,9 @@ func Test_ShowAppHelp_HideVersion(t *testing.T) { c := NewContext(app, nil, nil) - ShowAppHelp(c) + _ = ShowAppHelp(c) - if bytes.Index(output.Bytes(), []byte("VERSION:")) != -1 { + if bytes.Contains(output.Bytes(), []byte("VERSION:")) { t.Errorf("expected\n%snot to include %s", output.String(), "VERSION:") } } @@ -77,7 +77,7 @@ func Test_Help_Custom_Flags(t *testing.T) { } output := new(bytes.Buffer) app.Writer = output - app.Run([]string{"test", "-h"}) + _ = app.Run([]string{"test", "-h"}) if output.Len() > 0 { t.Errorf("unexpected output: %s", output.String()) } @@ -108,7 +108,7 @@ func Test_Version_Custom_Flags(t *testing.T) { } output := new(bytes.Buffer) app.Writer = output - app.Run([]string{"test", "-v"}) + _ = app.Run([]string{"test", "-v"}) if output.Len() > 0 { t.Errorf("unexpected output: %s", output.String()) } @@ -118,7 +118,7 @@ func Test_helpCommand_Action_ErrorIfNoTopic(t *testing.T) { app := &App{} set := flag.NewFlagSet("test", 0) - set.Parse([]string{"foo"}) + _ = set.Parse([]string{"foo"}) c := NewContext(app, set, nil) @@ -128,9 +128,9 @@ func Test_helpCommand_Action_ErrorIfNoTopic(t *testing.T) { t.Fatalf("expected error from helpCommand.Action(), but got nil") } - exitErr, ok := err.(*exitError) + exitErr, ok := err.(*ExitError) if !ok { - t.Fatalf("expected *exitError from helpCommand.Action(), but instead got: %v", err.Error()) + t.Fatalf("expected *ExitError from helpCommand.Action(), but instead got: %v", err.Error()) } if !strings.HasPrefix(exitErr.Error(), "No help topic for") { @@ -146,7 +146,7 @@ func Test_helpCommand_InHelpOutput(t *testing.T) { app := &App{} output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"test", "--help"}) + _ = app.Run([]string{"test", "--help"}) s := output.String() @@ -163,7 +163,7 @@ func Test_helpSubcommand_Action_ErrorIfNoTopic(t *testing.T) { app := &App{} set := flag.NewFlagSet("test", 0) - set.Parse([]string{"foo"}) + _ = set.Parse([]string{"foo"}) c := NewContext(app, set, nil) @@ -173,9 +173,9 @@ func Test_helpSubcommand_Action_ErrorIfNoTopic(t *testing.T) { t.Fatalf("expected error from helpCommand.Action(), but got nil") } - exitErr, ok := err.(*exitError) + exitErr, ok := err.(*ExitError) if !ok { - t.Fatalf("expected *exitError from helpCommand.Action(), but instead got: %v", err.Error()) + t.Fatalf("expected *ExitError from helpCommand.Action(), but instead got: %v", err.Error()) } if !strings.HasPrefix(exitErr.Error(), "No help topic for") { @@ -202,7 +202,7 @@ func TestShowAppHelp_CommandAliases(t *testing.T) { output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"foo", "--help"}) + _ = app.Run([]string{"foo", "--help"}) if !strings.Contains(output.String(), "frobbly, fr, frob") { t.Errorf("expected output to include all command aliases; got: %q", output.String()) @@ -224,7 +224,7 @@ func TestShowCommandHelp_CommandAliases(t *testing.T) { output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"foo", "help", "fr"}) + _ = app.Run([]string{"foo", "help", "fr"}) if !strings.Contains(output.String(), "frobbly") { t.Errorf("expected output to include command name; got: %q", output.String()) @@ -250,7 +250,7 @@ func TestShowSubcommandHelp_CommandAliases(t *testing.T) { output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"foo", "help"}) + _ = app.Run([]string{"foo", "help"}) if !strings.Contains(output.String(), "frobbly, fr, frob, bork") { t.Errorf("expected output to include all command aliases; got: %q", output.String()) @@ -284,7 +284,7 @@ EXAMPLES: } output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"foo", "help", "frobbly"}) + _ = app.Run([]string{"foo", "help", "frobbly"}) if strings.Contains(output.String(), "2. Frobbly runs without this param locally.") { t.Errorf("expected output to exclude \"2. Frobbly runs without this param locally.\"; got: %q", output.String()) @@ -312,7 +312,7 @@ func TestShowSubcommandHelp_CommandUsageText(t *testing.T) { output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"foo", "frobbly", "--help"}) + _ = app.Run([]string{"foo", "frobbly", "--help"}) if !strings.Contains(output.String(), "this is usage text") { t.Errorf("expected output to include usage text; got: %q", output.String()) @@ -336,7 +336,7 @@ func TestShowSubcommandHelp_SubcommandUsageText(t *testing.T) { output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"foo", "frobbly", "bobbly", "--help"}) + _ = app.Run([]string{"foo", "frobbly", "bobbly", "--help"}) if !strings.Contains(output.String(), "this is usage text") { t.Errorf("expected output to include usage text; got: %q", output.String()) @@ -364,7 +364,7 @@ func TestShowAppHelp_HiddenCommand(t *testing.T) { output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"app", "--help"}) + _ = app.Run([]string{"app", "--help"}) if strings.Contains(output.String(), "secretfrob") { t.Errorf("expected output to exclude \"secretfrob\"; got: %q", output.String()) @@ -422,7 +422,7 @@ VERSION: output := &bytes.Buffer{} app.Writer = output - app.Run([]string{"app", "--help"}) + _ = app.Run([]string{"app", "--help"}) if strings.Contains(output.String(), "secretfrob") { t.Errorf("expected output to exclude \"secretfrob\"; got: %q", output.String()) diff --git a/helpers_unix_test.go b/helpers_unix_test.go deleted file mode 100644 index ae27fc5..0000000 --- a/helpers_unix_test.go +++ /dev/null @@ -1,9 +0,0 @@ -// +build darwin dragonfly freebsd linux netbsd openbsd solaris - -package cli - -import "os" - -func clearenv() { - os.Clearenv() -} diff --git a/helpers_windows_test.go b/helpers_windows_test.go deleted file mode 100644 index 4eb84f9..0000000 --- a/helpers_windows_test.go +++ /dev/null @@ -1,20 +0,0 @@ -package cli - -import ( - "os" - "syscall" -) - -// os.Clearenv() doesn't actually unset variables on Windows -// See: https://github.com/golang/go/issues/17902 -func clearenv() { - for _, s := range os.Environ() { - for j := 1; j < len(s); j++ { - if s[j] == '=' { - keyp, _ := syscall.UTF16PtrFromString(s[0:j]) - syscall.SetEnvironmentVariable(keyp, nil) - break - } - } - } -} diff --git a/parse.go b/parse.go new file mode 100644 index 0000000..865accf --- /dev/null +++ b/parse.go @@ -0,0 +1,80 @@ +package cli + +import ( + "flag" + "strings" +) + +type iterativeParser interface { + newFlagSet() (*flag.FlagSet, error) + useShortOptionHandling() bool +} + +// To enable short-option handling (e.g., "-it" vs "-i -t") we have to +// iteratively catch parsing errors. This way we achieve LR parsing without +// transforming any arguments. Otherwise, there is no way we can discriminate +// combined short options from common arguments that should be left untouched. +func parseIter(ip iterativeParser, args []string) (*flag.FlagSet, error) { + for { + set, err := ip.newFlagSet() + if err != nil { + return nil, err + } + + err = set.Parse(args) + if !ip.useShortOptionHandling() || err == nil { + return set, err + } + + errStr := err.Error() + trimmed := strings.TrimPrefix(errStr, "flag provided but not defined: ") + if errStr == trimmed { + return nil, err + } + + // regenerate the initial args with the split short opts + newArgs := []string{} + for i, arg := range args { + if arg != trimmed { + newArgs = append(newArgs, arg) + continue + } + + shortOpts := splitShortOptions(set, trimmed) + if len(shortOpts) == 1 { + return nil, err + } + + // add each short option and all remaining arguments + newArgs = append(newArgs, shortOpts...) + newArgs = append(newArgs, args[i+1:]...) + args = newArgs + } + } +} + +func splitShortOptions(set *flag.FlagSet, arg string) []string { + shortFlagsExist := func(s string) bool { + for _, c := range s[1:] { + if f := set.Lookup(string(c)); f == nil { + return false + } + } + return true + } + + if !isSplittable(arg) || !shortFlagsExist(arg) { + return []string{arg} + } + + separated := make([]string, 0, len(arg)-1) + for _, flagChar := range arg[1:] { + separated = append(separated, "-"+string(flagChar)) + } + + return separated +} + +func isSplittable(flagArg string) bool { + return strings.HasPrefix(flagArg, "-") && !strings.HasPrefix(flagArg, "--") && len(flagArg) > 2 +} diff --git a/runtests b/runtests deleted file mode 100755 index d2c5ea6..0000000 --- a/runtests +++ /dev/null @@ -1,172 +0,0 @@ -#!/usr/bin/env python -from __future__ import print_function, unicode_literals - -import argparse -import codecs -import glob -import os -import platform -import shutil -import sys -import tempfile - -from subprocess import check_call, check_output - - -_PY3 = sys.version_info.major == 3 -_WINDOWS = platform.system().lower() == 'windows' -_PACKAGE_NAME = os.environ.get( - 'CLI_PACKAGE_NAME', 'github.com/urfave/cli' -) -_TARGETS = {} - - -def main(sysargs=sys.argv[:]): - 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 _target(func): - _TARGETS[func.__name__.strip('_')] = func - return func - - -@_target -def _test(): - if _go_version() < '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) - - -@_target -def _gfmrun(): - go_version = _go_version() - 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']) - - -@_target -def _vet(): - _run('go vet ./...') - - -@_target -def _migrations(): - go_version = _go_version() - if go_version < 'go1.3': - print('runtests: skip on {}'.format(go_version), file=sys.stderr) - return - - migration_script = os.path.abspath( - os.environ.get('V1TOV2', './cli-v1-to-v2') - ) - v1_readme_url = os.environ.get( - 'V1README', - 'https://raw.githubusercontent.com/urfave/cli/v1/README.md' - ) - - tmpdir = tempfile.mkdtemp() - try: - os.chdir(tmpdir) - _run('curl -sSL -o README.md {}'.format(v1_readme_url).split()) - _run('gfmrun extract -o .'.split()) - - for gofile in glob.glob('*.go'): - for i in (0, 1): - _run(['python', migration_script, '-w', gofile]) - _run('go build -o tmp.out {}'.format(gofile).split()) - finally: - if os.environ.get('NOCLEAN', '') == '': - shutil.rmtree(tmpdir, ignore_errors=True) - - -@_target -def _toc(): - exe = ['bash'] if _WINDOWS else [] - _run(exe + [ - os.path.join('node_modules', '.bin', 'markdown-toc'), - '-i', 'README.md' - ]) - _run('git diff --exit-code') - - -@_target -def _gen(): - go_version = _go_version() - 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) - sys.stderr.flush() - check_call(command) - - -def _gfmrun_count(): - with codecs.open('README.md', 'r', 'utf-8') as infile: - lines = infile.read().splitlines() - return len(list(filter(_is_go_runnable, lines))) - - -def _is_go_runnable(line): - return line.startswith('package main') - - -def _go_version(): - return check_output('go version'.split()).decode('utf-8').split()[2] - - -def _combine_coverprofiles(coverprofiles): - tmp_args = dict(suffix='.coverprofile', mode='w', delete=False) - if _PY3: - tmp_args['encoding'] = 'utf-8' - - combined = tempfile.NamedTemporaryFile(**tmp_args) - combined.write('mode: set\n') - - for coverprofile in coverprofiles: - with codecs.open(coverprofile, 'r', 'utf-8') 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()) diff --git a/sort.go b/sort.go new file mode 100644 index 0000000..23d1c2f --- /dev/null +++ b/sort.go @@ -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 +} diff --git a/sort_test.go b/sort_test.go new file mode 100644 index 0000000..662ef9b --- /dev/null +++ b/sort_test.go @@ -0,0 +1,30 @@ +package cli + +import "testing" + +var lexicographicLessTests = []struct { + i string + j string + expected bool +}{ + {"", "a", true}, + {"a", "", false}, + {"a", "a", false}, + {"a", "A", false}, + {"A", "a", true}, + {"aa", "a", false}, + {"a", "aa", true}, + {"a", "b", true}, + {"a", "B", true}, + {"A", "b", true}, + {"A", "B", true}, +} + +func TestLexicographicLess(t *testing.T) { + for _, test := range lexicographicLessTests { + actual := lexicographicLess(test.i, test.j) + if test.expected != actual { + t.Errorf(`expected string "%s" to come before "%s"`, test.i, test.j) + } + } +} diff --git a/template.go b/template.go new file mode 100644 index 0000000..c631fb9 --- /dev/null +++ b/template.go @@ -0,0 +1,121 @@ +package cli + +// 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}}:{{range .VisibleCommands}} + {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{else}}{{range .VisibleCommands}} + {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{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}}:{{range .VisibleCommands}} + {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{else}}{{range .VisibleCommands}} + {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{end}}{{end}}{{if .VisibleFlags}} + +OPTIONS: + {{range .VisibleFlags}}{{.}} + {{end}}{{end}} +` + +var MarkdownDocTemplate = `% {{ .App.Name }}(8) {{ .App.Description }} + +% {{ .App.Author }} + +# NAME + +{{ .App.Name }}{{ if .App.Usage }} - {{ .App.Usage }}{{ end }} + +# SYNOPSIS + +{{ .App.Name }} +{{ if .SynopsisArgs }} +` + "```" + ` +{{ range $v := .SynopsisArgs }}{{ $v }}{{ end }}` + "```" + ` +{{ end }}{{ if .App.UsageText }} +# DESCRIPTION + +{{ .App.UsageText }} +{{ end }} +**Usage**: + +` + "```" + ` +{{ .App.Name }} [GLOBAL OPTIONS] command [COMMAND OPTIONS] [ARGUMENTS...] +` + "```" + ` +{{ if .GlobalArgs }} +# GLOBAL OPTIONS +{{ range $v := .GlobalArgs }} +{{ $v }}{{ end }} +{{ end }}{{ if .Commands }} +# COMMANDS +{{ range $v := .Commands }} +{{ $v }}{{ end }}{{ end }}` + +var FishCompletionTemplate = `# {{ .App.Name }} fish shell completion + +function __fish_{{ .App.Name }}_no_subcommand --description 'Test if there has been any subcommand yet' + for i in (commandline -opc) + if contains -- $i{{ range $v := .AllCommands }} {{ $v }}{{ end }} + return 1 + end + end + return 0 +end + +{{ range $v := .Completions }}{{ $v }} +{{ end }}` diff --git a/testdata/expected-doc-full.man b/testdata/expected-doc-full.man new file mode 100644 index 0000000..5190698 --- /dev/null +++ b/testdata/expected-doc-full.man @@ -0,0 +1,80 @@ +.nh +.TH greet(8) + +.SH Harrison + +.SH NAME +.PP +greet \- Some app + + +.SH SYNOPSIS +.PP +greet + +.PP +.RS + +.nf +[\-\-another\-flag|\-b] +[\-\-flag|\-\-fl|\-f]=[value] +[\-\-socket|\-s]=[value] + +.fi +.RE + + +.SH DESCRIPTION +.PP +app [first\_arg] [second\_arg] + +.PP +\fBUsage\fP: + +.PP +.RS + +.nf +greet [GLOBAL OPTIONS] command [COMMAND OPTIONS] [ARGUMENTS...] + +.fi +.RE + + +.SH GLOBAL OPTIONS +.PP +\fB\-\-another\-flag, \-b\fP: another usage text + +.PP +\fB\-\-flag, \-\-fl, \-f\fP="": + +.PP +\fB\-\-socket, \-s\fP="": some 'usage' text (default: value) + + +.SH COMMANDS +.SH config, c +.PP +another usage test + +.PP +\fB\-\-another\-flag, \-b\fP: another usage text + +.PP +\fB\-\-flag, \-\-fl, \-f\fP="": + +.SS sub\-config, s, ss +.PP +another usage test + +.PP +\fB\-\-sub\-command\-flag, \-s\fP: some usage text + +.PP +\fB\-\-sub\-flag, \-\-sub\-fl, \-s\fP="": + +.SH info, i, in +.PP +retrieve generic information + +.SH some\-command \ No newline at end of file diff --git a/testdata/expected-doc-full.md b/testdata/expected-doc-full.md new file mode 100644 index 0000000..23d7c23 --- /dev/null +++ b/testdata/expected-doc-full.md @@ -0,0 +1,62 @@ +% greet(8) + +% Harrison + +# NAME + +greet - Some app + +# SYNOPSIS + +greet + +``` +[--another-flag|-b] +[--flag|--fl|-f]=[value] +[--socket|-s]=[value] +``` + +# DESCRIPTION + +app [first_arg] [second_arg] + +**Usage**: + +``` +greet [GLOBAL OPTIONS] command [COMMAND OPTIONS] [ARGUMENTS...] +``` + +# GLOBAL OPTIONS + +**--another-flag, -b**: another usage text + +**--flag, --fl, -f**="": + +**--socket, -s**="": some 'usage' text (default: value) + + +# COMMANDS + +## config, c + +another usage test + +**--another-flag, -b**: another usage text + +**--flag, --fl, -f**="": + +### sub-config, s, ss + +another usage test + +**--sub-command-flag, -s**: some usage text + +**--sub-flag, --sub-fl, -s**="": + +## info, i, in + +retrieve generic information + +## some-command + + diff --git a/testdata/expected-doc-no-commands.md b/testdata/expected-doc-no-commands.md new file mode 100644 index 0000000..18d8e35 --- /dev/null +++ b/testdata/expected-doc-no-commands.md @@ -0,0 +1,36 @@ +% greet(8) + +% Harrison + +# NAME + +greet - Some app + +# SYNOPSIS + +greet + +``` +[--another-flag|-b] +[--flag|--fl|-f]=[value] +[--socket|-s]=[value] +``` + +# DESCRIPTION + +app [first_arg] [second_arg] + +**Usage**: + +``` +greet [GLOBAL OPTIONS] command [COMMAND OPTIONS] [ARGUMENTS...] +``` + +# GLOBAL OPTIONS + +**--another-flag, -b**: another usage text + +**--flag, --fl, -f**="": + +**--socket, -s**="": some 'usage' text (default: value) + diff --git a/testdata/expected-doc-no-flags.md b/testdata/expected-doc-no-flags.md new file mode 100644 index 0000000..8ce60fd --- /dev/null +++ b/testdata/expected-doc-no-flags.md @@ -0,0 +1,47 @@ +% greet(8) + +% Harrison + +# NAME + +greet - Some app + +# SYNOPSIS + +greet + +# DESCRIPTION + +app [first_arg] [second_arg] + +**Usage**: + +``` +greet [GLOBAL OPTIONS] command [COMMAND OPTIONS] [ARGUMENTS...] +``` + +# COMMANDS + +## config, c + +another usage test + +**--another-flag, -b**: another usage text + +**--flag, --fl, -f**="": + +### sub-config, s, ss + +another usage test + +**--sub-command-flag, -s**: some usage text + +**--sub-flag, --sub-fl, -s**="": + +## info, i, in + +retrieve generic information + +## some-command + + diff --git a/testdata/expected-fish-full.fish b/testdata/expected-fish-full.fish new file mode 100644 index 0000000..b18d51e --- /dev/null +++ b/testdata/expected-fish-full.fish @@ -0,0 +1,28 @@ +# greet fish shell completion + +function __fish_greet_no_subcommand --description 'Test if there has been any subcommand yet' + for i in (commandline -opc) + if contains -- $i config c sub-config s ss info i in some-command + return 1 + end + end + return 0 +end + +complete -c greet -n '__fish_greet_no_subcommand' -l socket -s s -r -d 'some \'usage\' text' +complete -c greet -n '__fish_greet_no_subcommand' -f -l flag -s fl -s f -r +complete -c greet -n '__fish_greet_no_subcommand' -f -l another-flag -s b -d 'another usage text' +complete -c greet -n '__fish_greet_no_subcommand' -f -l help -s h -d 'show help' +complete -c greet -n '__fish_greet_no_subcommand' -f -l version -s v -d 'print the version' +complete -c greet -n '__fish_seen_subcommand_from config c' -f -l help -s h -d 'show help' +complete -r -c greet -n '__fish_greet_no_subcommand' -a 'config c' -d 'another usage test' +complete -c greet -n '__fish_seen_subcommand_from config c' -l flag -s fl -s f -r +complete -c greet -n '__fish_seen_subcommand_from config c' -f -l another-flag -s b -d 'another usage text' +complete -c greet -n '__fish_seen_subcommand_from sub-config s ss' -f -l help -s h -d 'show help' +complete -r -c greet -n '__fish_seen_subcommand_from config c' -a 'sub-config s ss' -d 'another usage test' +complete -c greet -n '__fish_seen_subcommand_from sub-config s ss' -f -l sub-flag -s sub-fl -s s -r +complete -c greet -n '__fish_seen_subcommand_from sub-config s ss' -f -l sub-command-flag -s s -d 'some usage text' +complete -c greet -n '__fish_seen_subcommand_from info i in' -f -l help -s h -d 'show help' +complete -r -c greet -n '__fish_greet_no_subcommand' -a 'info i in' -d 'retrieve generic information' +complete -c greet -n '__fish_seen_subcommand_from some-command' -f -l help -s h -d 'show help' +complete -r -c greet -n '__fish_greet_no_subcommand' -a 'some-command'