cli: support "-" and "@" for pipes and files (#365)

This PR adds support for flags to optionally allow the user to specify
special syntaxes that tell the CLI to read the contents from a pipe,
prompt, or file. This behavior is off by default and must be enabled on
a per-flag basis.

- If a flag sets `AllowFromFile` to true, then if the value for the flag
starts with an "@" symbol, the argument is interpreted as a filepath and
the contents are read from disk. This is theoretically possible today
with shellisms (e.g. `-foo=$(cat bar.txt)`), but this provides a
shell-agnostic implementation. If the file does not start with "@", then
the value is read as a string as normal. As a special case where the
user really wanted the value to be the literal "@", "\\@" can be used to
escape the input.

- If a flag sets `AllowFromPrompt` to true, then if the value for the
flag is exactly the string "-", then the flag expects input from stdin
or a tty. If neither are present, then the user is prompted. As a
special case where the user really wanted the literal value "-", "\\-"
can be used to escape the input.

Again, both of these behaviors are off by default and must be enabled on
a per-flag basis. In general, I don't expect many flags will use this
configuration, but it's useful to be consistent where necessary.

Finally, it looks like there are some new linting errors, since the
linter was failing locally for me, so I fixed those up.

Author: sethvargo

.golangci.yml

@@ -33,16 +33,15 @@ linters:
     - 'bidichk'
     - 'bodyclose'
     - 'containedctx'
+    # - 'copyloopvar' TODO: enable after everything is upgraded to Go 1.22
     - 'depguard'
     - 'dupword'
     - 'durationcheck'
     - 'errcheck'
     - 'errchkjson'
     - 'errname'
     - 'errorlint'
-    - 'execinquery'
     - 'exhaustive'
-    - 'exportloopref'
     - 'forcetypeassert'
     - 'gci'
     - 'gocheckcompilerdirectives'
@@ -170,7 +169,7 @@ linters-settings:
 
   sloglint:
     # default: false
-    context-only: true
+    context: 'all'
     # default: false
     static-msg: false
     # default: '' (snake, kebab, camel, pascal)

cache/cache.go

@@ -90,8 +90,8 @@ func New[T any](expireAfter time.Duration) *Cache[T] {
 	// largely defeat the purpose. In this case, 50ms is somewhat arbitrary, but
 	// it ensures the CPU is not entirely bound by the sweep operation.
 	sweep := expireAfter / 4.0
-	if min := 50 * time.Millisecond; sweep < min {
-		sweep = min
+	if minimum := 50 * time.Millisecond; sweep < minimum {
+		sweep = minimum
 	}
 	go c.start(sweep)
 

cli/command.go

@@ -262,8 +262,15 @@ type BaseCommand struct {
 }
 
 // NewFlagSet creates a new flag set that inherits properties from the command.
-func (c *BaseCommand) NewFlagSet(opts ...Option) *FlagSet {
-	return NewFlagSet(WithLookupEnv(c.LookupEnv))
+func (c *BaseCommand) NewFlagSet(o ...Option) *FlagSet {
+	opts := []Option{
+		WithLookupEnv(c.LookupEnv),
+		WithPromptAll(c.PromptAll),
+		WithWorkingDir(c.WorkingDir),
+	}
+	opts = append(opts, o...)
+
+	return NewFlagSet(opts...)
 }
 
 // Flags returns the base command flags, which is always nil.
@@ -483,22 +490,7 @@ func (c *BaseCommand) GetEnv(key string) string {
 // WorkingDir returns the absolute path of current working directory from where
 // the command was started. All symlinks are resolved to their real paths.
 func (c *BaseCommand) WorkingDir() (string, error) {
-	cwd, err := os.Getwd()
-	if err != nil {
-		return "", fmt.Errorf("failed to get current working directory: %w", err)
-	}
-
-	symCwd, err := filepath.EvalSymlinks(cwd)
-	if err != nil {
-		return "", fmt.Errorf("failed to resolve symlinks for current working directory: %w", err)
-	}
-
-	abs, err := filepath.Abs(symCwd)
-	if err != nil {
-		return "", fmt.Errorf("failed to compute absolute path for current working directory: %w", err)
-	}
-
-	return abs, nil
+	return workingDir()
 }
 
 // ExecutablePath returns the absolute path of the CLI executable binary. All
@@ -575,3 +567,22 @@ func buildCompleteCommands(cmd Command) *complete.Command {
 
 	return completer
 }
+
+func workingDir() (string, error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", fmt.Errorf("failed to get current working directory: %w", err)
+	}
+
+	symCwd, err := filepath.EvalSymlinks(cwd)
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve symlinks for current working directory: %w", err)
+	}
+
+	abs, err := filepath.Abs(symCwd)
+	if err != nil {
+		return "", fmt.Errorf("failed to compute absolute path for current working directory: %w", err)
+	}
+
+	return abs, nil
+}

cli/command_doc_test.go

@@ -74,13 +74,13 @@ func (c *CountCommand) Run(ctx context.Context, args []string) error {
 		return fmt.Errorf("expected 1 argument, got %q", args)
 	}
 
-	maxStr := args[0]
-	max, err := strconv.ParseInt(maxStr, 10, 64)
+	maximumStr := args[0]
+	maximum, err := strconv.ParseInt(maximumStr, 10, 64)
 	if err != nil {
 		return fmt.Errorf("failed to parse max: %w", err)
 	}
 
-	for i := int64(0); i <= max; i += c.flagStep {
+	for i := int64(0); i <= maximum; i += c.flagStep {
 		c.Outf("%d", i)
 	}