Simple but powerful command line option parsing library for Go supporting subcommand.

# Flag
[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/cosiner/flag) 

Flag is a simple but powerful commandline flag parsing library for [Go](https://golang.org).

# Documentation
Documentation can be found at [Godoc](https://godoc.org/github.com/cosiner/flag)

# Supported features
* bool
  * `-f`, `-f=false`, `-f=true`, there is no `-f true` and `-f false` to avoid conflicting 
    with positional flag and non-flag values
* string,number
  * `-f a.go -n 100`
* slice:
  * `-f a.go -f b.go -f c.go`
* hint flag as value
  * `--` to hint next argument is value: `rm -- -a.go`, 
    `rm -- -a.go -b.go` will throws error for `-b.go` is invalid flag
  * `--*` to hint latter all arguments are value: `rm -- -a.go -b.go -c.go`
* useful tricks:
  * `-f a.go`, `-f=a.go`, `--file=a.go`
  * `-zcf=a.go`, `-zcf a.go`
  * `-I/usr/include`: only works for `-[a-zA-Z][^a-zA-Z].+`
* catch non-flag arguments:
  * `rm -rf a.go b.go c.go`, catchs `[a.go, b.go, c.go]` 
* positional flag:
  * `cp -f src.go dst.go`, catchs `SOURCE=a.go DESTINATION=dst.go`
  * This is implemented as a special case of non-flag arguments, positional flags will be applied first, and remain values
* value apply/checking
  * default value
  * environment value
  * value list for user selecting
* multiple flag names for one flag
* subcommand.

# Definition via structure field tag
* `names`: flag/command names, comma-speparated, default uses camelCase of field name(with a `-` prefix for flag)
  * `-` to skip this field
  * `@` to indicate that this is a positional flag
  * support multiple name and formats: eg: `-f, --file, -file'
* `arglist`: argument list for command or argument name for flag
  * for positional flag, this will also be used as it's display name if defined, otherwise field name is used.
  * command example: eg: `[OPTION]... SOURCE DESTINATION`, or `[FLAG]... FILE [ARG}...` 
  * flag example: eg: 'FILE', 'DESTINATION'
* `version`: version message for command
* `usage`: short description
* `desc`: long description
* `env`: environment name for flag, if user doesn't passed this flag, environment value will be used
* `default`: default value for flag, if user doesn't passed this flag and environment value not defined, it will be used 
* `args`: used to catching non-flag arguments, it's type must be `[]string`

* special cases
  * `Enable`, there must be a `Enable` field inside command to indicate whether user are using this command.
  * `Args`: this field will be used to store non-flag arguments if `args` tag is not defined
  * `Metadata`: structure could implement this interface to override settings defined by tags
  ```Go
    type Metadata interface {
	    // the key is comma-separated flag name to find command/flag,
        // each component represents a level, "" represents root command
        Metadata() map[string]Flag
    }
  ```
  
# Example
## Flags
```Go
package flag

import "fmt"

type Tar struct {
	GZ          bool     `names:"-z, --gz" usage:"gzip format"`
	BZ          bool     `names:"-j, --bz" usage:"bzip2 format"`
	XZ          bool     `names:"-J, --xz" usage:"xz format"`
	Create      bool     `names:"-c" usage:"create tar file"`
	Extract     bool     `names:"-x" usage:"extract tar file"`
	File        string   `names:"-f" usage:"output file for create or input file for extract"`
	Directory   string   `names:"-C" usage:"extract directory"`
	SourceFiles []string `args:"true"`
}

func (t *Tar) Metadata() map[string]Flag {
	const (
		usage   = "tar is a tool for manipulate tape archives."
		version = `
			version: v1.0.0
			commit: 10adf10dc10
			date:   2017-01-01 10:00:01
		`
		desc = `
		tar creates and manipulates streaming archive files.  This implementation can extract
		from tar, pax, cpio, zip, jar, ar, and ISO 9660 cdrom images and can create tar, pax,
		cpio, ar, and shar archives.
		`
	)
	return map[string]Flag{
		"": {
			Usage:   usage,
			Version: version,
			Desc:    desc,
		},
		"--gz": {
			Desc: "use gzip format",
		},
	}
}

func ExampleFlagSet_ParseStruct() {
	var tar Tar

	NewFlagSet(Flag{}).ParseStruct(&tar, "tar", "-zcf", "a.tgz", "a.go", "b.go")
	fmt.Println(tar.GZ)
	fmt.Println(tar.Create)
	fmt.Println(tar.File)
	fmt.Println(tar.SourceFiles)

	// Output:
	// true
	// true
	// a.tgz
	// [a.go b.go]
}

```
## Help message
```
tar is a tool for manipulate tape archives.

Usage:
      flag.test [FLAG]...

Version:
      version: v1.0.0
      commit: 10adf10dc10
      date:   2017-01-01 10:00:01

Description:
      tar creates and manipulates streaming archive files.  This implementation can extract
      from tar, pax, cpio, zip, jar, ar, and ISO 9660 cdrom images and can create tar, pax,
      cpio, ar, and shar archives.

Flags:
      -z, --gz     gzip format (bool)
            use gzip format
      -j, --bz     bzip2 format (bool)
      -J, --xz     xz format (bool)
      -c           create tar file (bool)
      -x           extract tar file (bool)
      -f           output file for create or input file for extract (string)
      -C           extract directory (string)
```

## FlagSet
```Go

type GoCmd struct {
	Build struct {
		Enable  bool
		Already bool   `names:"-a" important:"1" desc:"force rebuilding of packages that are already up-to-date."`
		Race    bool   `important:"1" desc:"enable data race detection.\nSupported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64."`
		Output  string `names:"-o" arglist:"output" important:"1" desc:"only allowed when compiling a single package"`

		LdFlags  string   `names:"-ldflags" arglist:"'flag list'" desc:"arguments to pass on each go tool link invocation."`
		Packages []string `args:"true"`
	} `usage:"compile packages and dependencies"`
	Clean struct {
		Enable bool
	} `usage:"remove object files"`
	Doc struct {
		Enable bool
	} `usage:"show documentation for package or symbol"`
	Env struct {
		Enable bool
	} `usage:"print Go environment information"`
	Bug struct {
		Enable bool
	} `usage:"start a bug report"`
	Fix struct {
		Enable bool
	} `usage:"run go tool fix on packages"`
	Fmt struct {
		Enable bool
	} `usage:"run gofmt on package sources"`
}

func (*GoCmd) Metadata() map[string]Flag {
	return map[string]Flag{
		"": {
			Usage:   "Go is a tool for managing Go source code.",
			Arglist: "command [argument]",
		},
		"build": {
			Arglist: "[-o output] [-i] [build flags] [packages]",
			Desc: `
		Build compiles the packages named by the import paths,
		along with their dependencies, but it does not install the results.
		...
		The build flags are shared by the build, clean, get, install, list, run,
		and test commands:
			`,
		},
	}
}

func TestSubset(t *testing.T) {
	var g GoCmd

	set := NewFlagSet(Flag{})
	set.StructFlags(&g)
	set.Help(false)
	fmt.Println()
	build, _ := set.FindSubset("build")
	build.Help(false)
}
```
##Help Message
```
Go is a tool for managing Go source code.

Usage:
      flag.test command [argument]

Sets:
      build        compile packages and dependencies
      clean        remove object files
      doc          show documentation for package or symbol
      env          print Go environment information
      bug          start a bug report
      fix          run go tool fix on packages
      fmt          run gofmt on package sources
```
```
compile packages and dependencies

Usage:
      build [-o output] [-i] [build flags] [packages]

Description:
      Build compiles the packages named by the import paths,
      along with their dependencies, but it does not install the results.
      ...
      The build flags are shared by the build, clean, get, install, list, run,
      and test commands:

Flags:
      -a                  
            force rebuilding of packages that are already up-to-date.
      -race               
            enable data race detection.
            Supported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64.
      -o output           
            only allowed when compiling a single package

      -ldflags 'flag list'
            arguments to pass on each go tool link invocation.
```
# LICENSE
MIT.


flag

A CLI program to encrypt/decrypt [andOTP](https://github.com/andOTP/andOTP) files. Can be used as a library as well.

# go-andotp
CLI program to encrypt/decrypt [andOTP](https://github.com/andOTP/andOTP) files.

## Installation

<details>
<summary>Linux</summary>

Download:
* [x86_64](https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-linux-x86_64) Intel or AMD 64-Bit CPU
 ```shell
 curl -L "https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-linux-x86_64" \
 -o "go-andotp" && \
 chmod +x "go-andotp"
 ```
* [arm64](https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-linux-arm64) Arm-based 64-Bit CPU (i.e. in Raspberry Pi)
 ```shell
 curl -L "https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-linux-arm64" \
 -o "go-andotp" && \
 chmod +x "go-andotp"
 ```

To determine your OS version, run `getconf LONG_BIT` or `uname -m` at the command line.
</details>

<details>
<summary>macOS</summary>

Download:
* [x86_64](https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-macos-x86_64) Intel 64-bit
 ```shell
 curl -L "https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-macos-x86_64" \
 -o "go-andotp" && \
 chmod +x "go-andotp"
 ```
* [arm64](https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-macos-arm64) Apple silicon 64-bit
 ```shell
 curl -L "https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-macos-arm64" \
 -o "go-andotp" && \
 chmod +x "go-andotp"
 ```

To determine your OS version, run `uname -m` at the command line.
</details>

<details>
<summary>Windows</summary>

Download:
* [x86_64](https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-windows-x86_64.exe) Intel or AMD 64-Bit CPU
 ```powershell
 Invoke-WebRequest -Uri "https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-windows-x86_64.exe" -OutFile "go-andotp.exe"
 ```
* [arm64](https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-windows-arm64.exe) Arm-based 64-Bit CPU
 ```powershell
 Invoke-WebRequest -Uri "https://github.com/RijulGulati/go-andotp/releases/latest/download/go-andotp-windows-arm64.exe" -OutFile "go-andotp.exe"
 ```
To determine your OS version, run `echo %PROCESSOR_ARCHITECTURE%` at the command line.
</details>

<details>
<summary>Go</summary>

```shell
go install github.com/grijul/go-andotp
```
</details>

## Usage
```text
Usage: go-andotp -i <INPUT_FILE> {-e|-d} [-o <OUT_FILE>] [-p PASSWORD]

 -d Decrypt file
 -e Encrypt file.
 -i string
 Input File
 -o string
 Output File. If no file is provided, output is printed to STDOUT
 -p string
 Encryption Password. This option can be skipped to get password prompt.
```

## Examples
- Encrypt JSON file (Password is asked after hitting ```Enter```. Password is not echoed)
```shell
go-andotp -e -i file.json -o file.json.aes
```
- Encrypt JSON file (Password is entered through CLI)
```shell
go-andotp -e -i file.json -o file.json.aes -p testpass
```
- Decrypt JSON file
```shell
go-andotp -d -i file.aes.json -o file.json
```
- Decrypt JSON file and print json to console
```shell
go-andotp -d -i file.aes.json
```

## Using go-andotp as library
go-andotp can be used as library as well. It implements ```Encrypt()``` and ```Decrypt()``` functions to encrypt/decrypt text (respectively).
It's documentation is available at: https://pkg.go.dev/github.com/grijul/go-andotp/andotp

Example usage:
```go
import "github.com/grijul/go-andotp/andotp"

func main() {
 andotp.Encrypt(...)
 andotp.Decrypt(...)
}
```

## Build
Compile `go-andotp` on your computer:

```shell
go build -o go-andotp main.go
```

To compile `go-andotp` for another platform please set the `GOARCH` and `GOOS` environmental variables.
Example:
```shell
GOOS=windows GOARCH=amd64 go build -o go-andotp.exe main.go
```

To compile `go-andotp` for Windows, macOS and Linux you can use the script `build.sh`:
```shell
bash build.sh
```

More help: <https://go.dev/doc/install/source#environment>

# License
[MIT](https://github.com/grijul/go-andotp/blob/main/LICENSE)

go-andotp

[![Documentation](https://godoc.org/github.com/yitsushi/go-commander?status.svg)](http://godoc.org/github.com/yitsushi/go-commander)
[![Go Report Card](https://goreportcard.com/badge/github.com/yitsushi/go-commander)](https://goreportcard.com/report/github.com/yitsushi/go-commander)
[![Coverage Status](https://coveralls.io/repos/github/yitsushi/go-commander/badge.svg)](https://coveralls.io/github/yitsushi/go-commander)
[![Build Status](https://travis-ci.org/yitsushi/go-commander.svg?branch=master)](https://travis-ci.org/yitsushi/go-commander)

This is a simple Go library to manage commands for your CLI tool.
Easy to use and now you can focus on Business Logic instead of building
the command routing.

### What this library does for you?

Manage your separated commands. How? Generates a general help and command
specific helps for your commands. If your command fails somewhere
(`panic` for example), commander will display the error message and
the command specific help to guide your user.

### Install

```shell
$ go get github.com/yitsushi/go-commander
```

### Sample output _(from [totp-cli](https://github.com/yitsushi/totp-cli))_

```shell
$ totp-cli help

change-password Change password
update Check and update totp-cli itself
version Print current version of this application
generate <namespace>.<account> Generate a specific OTP
add-token [namespace] [account] Add new token
list [namespace] List all available namespaces or accounts under a namespace
delete <namespace>[.account] Delete an account or a whole namespace
help [command] Display this help or a command specific help
```

### Usage

Every single command has to implement `CommandHandler`.
Check [this project](https://github.com/yitsushi/totp-cli) for examples.

```go
package main

// Import the package
import "github.com/yitsushi/go-commander"

// Your Command
type YourCommand struct {
}

// Executed only on command call
func (c *YourCommand) Execute(opts *commander.CommandHelper) {
 // Command Action
}

func NewYourCommand(appName string) *commander.CommandWrapper {
 return &commander.CommandWrapper{
 Handler: &YourCommand{},
 Help: &commander.CommandDescriptor{
 Name: "your-command",
 ShortDescription: "This is my own command",
 LongDescription: `This is a very long
description about this command.`,
 Arguments: "<filename> [optional-argument]",
 Examples: []string {
 "test.txt",
 "test.txt copy",
 "test.txt move",
 },
 },
 }
}

// Main Section
func main() {
	registry := commander.NewCommandRegistry()

	registry.Register(NewYourCommand)

	registry.Execute()
}
```

Now you have a CLI tool with two commands: `help` and `your-command`.

```bash
❯ go build mytool.go

❯ ./mytool
your-command <filename> [optional-argument] This is my own command
help [command] Display this help or a command specific help

❯ ./mytool help your-command
Usage: mytool your-command <filename> [optional-argument]

This is a very long
description about this command.

Examples:
 mytool your-command test.txt
 mytool your-command test.txt copy
 mytool your-command test.txt move
```

#### How to use subcommand pattern?

When you create your main command, just create a new `CommandRegistry` inside
the `Execute` function like you did in your `main()` and change `Depth`.

```go
import subcommand "github.com/yitsushi/mypackage/command/something"

func (c *Something) Execute(opts *commander.CommandHelper) {
	registry := commander.NewCommandRegistry()
	registry.Depth = 1
	registry.Register(subcommand.NewSomethingMySubCommand)
	registry.Execute()
}
```

### PreValidation

If you want to write a general pre-validation for your command
or just simply keep your validation logic separated:

```go
// Or you can define inline if you want
func MyValidator(c *commander.CommandHelper) {
 if c.Arg(0) == "" {
 panic("File?")
 }

 info, err := os.Stat(c.Arg(0))
 if err != nil {
 panic("File not found")
 }

 if !info.Mode().IsRegular() {
 panic("It's not a regular file")
 }

 if c.Arg(1) != "" {
 if c.Arg(1) != "copy" && c.Arg(1) != "move" {
 panic("Invalid operation")
 }
 }
}

func NewYourCommand(appName string) *commander.CommandWrapper {
 return &commander.CommandWrapper{
 Handler: &YourCommand{},
 Validator: MyValidator
 Help: &commander.CommandDescriptor{
 Name: "your-command",
 ShortDescription: "This is my own command",
 LongDescription: `This is a very long
description about this command.`,
 Arguments: "<filename> [optional-argument]",
 Examples: []string {
 "test.txt",
 "test.txt copy",
 "test.txt move",
 },
 },
 }
}
```


### Define arguments with type

```go
&commander.CommandWrapper{
 Handler: &MyCommand{},
 Arguments: []*commander.Argument{
 &commander.Argument{
 Name: "list",
 Type: "StringArray[]",
 },
 },
 Help: &commander.CommandDescriptor{
 Name: "my-command",
 },
}
```

In your command:

```go
if opts.HasValidTypedOpt("list") == nil {
 myList := opts.TypedOpt("list").([]string)
 if len(myList) > 0 {
 mockPrintf("My list: %v\n", myList)
 }
}
```

#### Define own type

Yes you can ;)

```go
// Define your struct (optional)
type MyCustomType struct {
	ID uint64
	Name string
}

// register your own type with parsing/validation
commander.RegisterArgumentType("MyType", func(value string) (interface{}, error) {
 values := strings.Split(value, ":")

 if len(values) < 2 {
 return &MyCustomType{}, errors.New("Invalid format! MyType => 'ID:Name'")
 }

 id, err := strconv.ParseUint(values[0], 10, 64)
 if err != nil {
 return &MyCustomType{}, errors.New("Invalid format! MyType => 'ID:Name'")
 }

 return &MyCustomType{
 ID: id,
 Name: values[1],
 },
 nil
})

// Define your command
&commander.CommandWrapper{
 Handler: &MyCommand{},
 Arguments: []*commander.Argument{
 &commander.Argument{
 Name: "owner",
 Type: "MyType",
 FailOnError: true, // Optional boolean
 },
 },
 Help: &commander.CommandDescriptor{
 Name: "my-command",
 },
}
```

In your command:

```go
if opts.HasValidTypedOpt("owner") == nil {
 owner := opts.TypedOpt("owner").(*MyCustomType)
 mockPrintf("OwnerID: %d, Name: %s\n", owner.ID, owner.Name)
}
```

go-commander

Go library for implementing command-line interfaces.

<center>
🚨 This project is archived. 🚨 <a href="https://gist.github.com/mitchellh/90029601268e59a29e64e55bab1c5bdc">Learn More</a>
</center>

<hr> 

# Go CLI Library [![GoDoc](https://godoc.org/github.com/mitchellh/cli?status.png)](https://pkg.go.dev/github.com/mitchellh/cli)

cli is a library for implementing command-line interfaces in Go.
cli is the library that powers the CLI for
[Packer](https://github.com/mitchellh/packer),
[Consul](https://github.com/hashicorp/consul),
[Vault](https://github.com/hashicorp/vault),
[Terraform](https://github.com/hashicorp/terraform),
[Nomad](https://github.com/hashicorp/nomad), and more.

## Features

* Easy sub-command based CLIs: `cli foo`, `cli bar`, etc.

* Support for nested subcommands such as `cli foo bar`.

* Optional support for default subcommands so `cli` does something
 other than error.

* Support for shell autocompletion of subcommands, flags, and arguments
 with callbacks in Go. You don't need to write any shell code.

* Automatic help generation for listing subcommands.

* Automatic help flag recognition of `-h`, `--help`, etc.

* Automatic version flag recognition of `-v`, `--version`.

* Helpers for interacting with the terminal, such as outputting information,
 asking for input, etc. These are optional, you can always interact with the
 terminal however you choose.

* Use of Go interfaces/types makes augmenting various parts of the library a
 piece of cake.

## Example

Below is a simple example of creating and running a CLI

```go
package main

import (
	"log"
	"os"

	"github.com/mitchellh/cli"
)

func main() {
	c := cli.NewCLI("app", "1.0.0")
	c.Args = os.Args[1:]
	c.Commands = map[string]cli.CommandFactory{
		"foo": fooCommandFactory,
		"bar": barCommandFactory,
	}

	exitStatus, err := c.Run()
	if err != nil {
		log.Println(err)
	}

	os.Exit(exitStatus)
}
```

mitchellh/cli

Simple API for creating interpreters and so much more.

[![GoDoc](https://godoc.org/github.com/Zaba505/sand?status.svg)](https://godoc.org/github.com/Zaba505/sand)
[![Go Report Card](https://goreportcard.com/badge/github.com/Zaba505/sand)](https://goreportcard.com/report/github.com/Zaba505/sand)
[![Build Status](https://travis-ci.com/Zaba505/sand.svg?branch=master)](https://travis-ci.com/Zaba505/sand)
[![Code Coverage](https://img.shields.io/codecov/c/github/Zaba505/sand/master.svg)](https://codecov.io/github/Zaba505/sand?branch=master)

# sand
`sand` is for creating interpreters, like the Python interpreter and Haskell interpreter.
It can also be used for creating text based games and CLI test environments.

For examples, check out the [examples](https://github.com/Zaba505/sand/tree/master/example) folder.

#### Design
`sand` implements a concurrent model. It views an interpreter as two seperate components:
the User Interface, `sand.UI`, and the Command Processor,`sand.Engine`. The following
diagram shows how under the hood `sand` operates. Every square is a goroutine.

```text
+--------+ +--------------------------+
| | +-------------> Engines Manager +--------------+
| Read <----------+ | +--------------------------+ |
| | | | |
+----+---+ | | |
 | +-+---+------+ +-------v------+
 | | | | | +----------+
 +------------> UI | | Engine | | Engine |
 | (usually +----------------------------------------> Runner +---->+ Exec |
 +------------> main) | | | | |
 | | | XXXXXXXXXXXXXXXXXXXXXXXXXXXX | | +----------+
 | +-+----------+ X Manager connects UI X +--------------+
+----+---+ | X to Engine Runner X
| | | XXXXXXXXXXXXXXXXXXXXXXXXXXXX
| Write <----------+
| |
+--------+

```

`sand.UI` is a `struct` that is provided for you and is implemented as broad as possible;
however there are few features missing, which are commonly found in popular interpreters,
namely: Line history and Auto-completion. These features may be added later, but as for
now they are not planned for.

`sand.Engine` is an `interface`, which must be implemented by the user. Implementations
of `sand.Engine` must have a comparable underlying type, see [Go Spec](https://golang.org/ref/spec#Comparison_operators)
for comparable types in Go.

sand

Build interactive and accessible prompts with full support for windows and posix terminals.

# Survey

[![GoDoc](http://img.shields.io/badge/godoc-reference-5272B4.svg)](https://pkg.go.dev/github.com/AlecAivazis/survey/v2)

A library for building interactive and accessible prompts on terminals supporting ANSI escape sequences.

⚠️ This project is no longer maintained. For an alternative, please check out: https://github.com/charmbracelet/bubbletea ⚠️

Hey everyone! I finally came to terms with the fact that I can no longer dedicate enough time to keep this library alive. 
This project outgrew my wildest expectations and was such a great experience. If someone else wants to take over maintainence,
please reach out


<img width="550" src="https://thumbs.gfycat.com/VillainousGraciousKouprey-size_restricted.gif"/>


```go
package main

import (
 "fmt"
 "github.com/AlecAivazis/survey/v2"
)

// the questions to ask
var qs = []*survey.Question{
 {
 Name: "name",
 Prompt: &survey.Input{Message: "What is your name?"},
 Validate: survey.Required,
 Transform: survey.Title,
 },
 {
 Name: "color",
 Prompt: &survey.Select{
 Message: "Choose a color:",
 Options: []string{"red", "blue", "green"},
 Default: "red",
 },
 },
 {
 Name: "age",
 Prompt: &survey.Input{Message: "How old are you?"},
 },
}

func main() {
 // the answers will be written to this struct
 answers := struct {
 Name string // survey will match the question and field names
 FavoriteColor string `survey:"color"` // or you can tag fields to match a specific name
 Age int // if the types don't match, survey will convert it
 }{}

 // perform the questions
 err := survey.Ask(qs, &answers)
 if err != nil {
 fmt.Println(err.Error())
 return
 }

 fmt.Printf("%s chose %s.", answers.Name, answers.FavoriteColor)
}
```

## Examples

Examples can be found in the `examples/` directory. Run them
to see basic behavior:

```bash
go run examples/simple.go
go run examples/validation.go
```

## Running the Prompts

There are two primary ways to execute prompts and start collecting information from your users: `Ask` and
`AskOne`. The primary difference is whether you are interested in collecting a single piece of information
or if you have a list of questions to ask whose answers should be collected in a single struct.
For most basic usecases, `Ask` should be enough. However, for surveys with complicated branching logic,
we recommend that you break out your questions into multiple calls to both of these functions to fit your needs.

### Configuring the Prompts

Most prompts take fine-grained configuration through fields on the structs you instantiate. It is also
possible to change survey's default behaviors by passing `AskOpts` to either `Ask` or `AskOne`. Examples
in this document will do both interchangeably:

```golang
prompt := &Select{
 Message: "Choose a color:",
 Options: []string{"red", "blue", "green"},
 // can pass a validator directly
 Validate: survey.Required,
}

// or define a default for the single call to `AskOne`
// the answer will get written to the color variable
survey.AskOne(prompt, &color, survey.WithValidator(survey.Required))

// or define a default for every entry in a list of questions
// the answer will get copied into the matching field of the struct as shown above
survey.Ask(questions, &answers, survey.WithValidator(survey.Required))
```

## Prompts

### Input

<img src="https://thumbs.gfycat.com/LankyBlindAmericanpainthorse-size_restricted.gif" width="400px"/>

```golang
name := ""
prompt := &survey.Input{
 Message: "ping",
}
survey.AskOne(prompt, &name)
```

#### Suggestion Options

<img src="https://i.imgur.com/Q7POpA1.gif" width="800px"/>

```golang
file := ""
prompt := &survey.Input{
 Message: "inform a file to save:",
 Suggest: func (toComplete string) []string {
 files, _ := filepath.Glob(toComplete + "*")
 return files
 },
}
}
survey.AskOne(prompt, &file)
```

### Multiline

<img src="https://thumbs.gfycat.com/ImperfectShimmeringBeagle-size_restricted.gif" width="400px"/>

```golang
text := ""
prompt := &survey.Multiline{
 Message: "ping",
}
survey.AskOne(prompt, &text)
```

### Password

<img src="https://thumbs.gfycat.com/CompassionateSevereHypacrosaurus-size_restricted.gif" width="400px" />

```golang
password := ""
prompt := &survey.Password{
 Message: "Please type your password",
}
survey.AskOne(prompt, &password)
```

### Confirm

<img src="https://thumbs.gfycat.com/UnkemptCarefulGermanpinscher-size_restricted.gif" width="400px"/>

```golang
name := false
prompt := &survey.Confirm{
 Message: "Do you like pie?",
}
survey.AskOne(prompt, &name)
```

### Select

<img src="https://thumbs.gfycat.com/GrimFilthyAmazonparrot-size_restricted.gif" width="450px"/>

```golang
color := ""
prompt := &survey.Select{
 Message: "Choose a color:",
 Options: []string{"red", "blue", "green"},
}
survey.AskOne(prompt, &color)
```

Fields and values that come from a `Select` prompt can be one of two different things. If you pass an `int`
the field will have the value of the selected index. If you instead pass a string, the string value selected
will be written to the field.

The user can also press `esc` to toggle the ability cycle through the options with the j and k keys to do down and up respectively.

By default, the select prompt is limited to showing 7 options at a time
and will paginate lists of options longer than that. This can be changed a number of ways:

```golang
// as a field on a single select
prompt := &survey.MultiSelect{..., PageSize: 10}

// or as an option to Ask or AskOne
survey.AskOne(prompt, &days, survey.WithPageSize(10))
```

#### Select options description

The optional description text can be used to add extra information to each option listed in the select prompt:

```golang
color := ""
prompt := &survey.Select{
 Message: "Choose a color:",
 Options: []string{"red", "blue", "green"},
 Description: func(value string, index int) string {
 if value == "red" {
 return "My favorite color"
 }
 return ""
 },
}
survey.AskOne(prompt, &color)

// Assuming that the user chose "red - My favorite color":
fmt.Println(color) //=> "red"
```

### MultiSelect

![Example](img/multi-select-all-none.gif)

```golang
days := []string{}
prompt := &survey.MultiSelect{
 Message: "What days do you prefer:",
 Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
}
survey.AskOne(prompt, &days)
```

Fields and values that come from a `MultiSelect` prompt can be one of two different things. If you pass an `int`
the field will have a slice of the selected indices. If you instead pass a string, a slice of the string values
selected will be written to the field.

The user can also press `esc` to toggle the ability cycle through the options with the j and k keys to do down and up respectively.

By default, the MultiSelect prompt is limited to showing 7 options at a time
and will paginate lists of options longer than that. This can be changed a number of ways:

```golang
// as a field on a single select
prompt := &survey.MultiSelect{..., PageSize: 10}

// or as an option to Ask or AskOne
survey.AskOne(prompt, &days, survey.WithPageSize(10))
```

### Editor

Launches the user's preferred editor (defined by the \$VISUAL or \$EDITOR environment variables) on a
temporary file. Once the user exits their editor, the contents of the temporary file are read in as
the result. If neither of those are present, notepad (on Windows) or vim (Linux or Mac) is used.

You can also specify a [pattern](https://golang.org/pkg/io/ioutil/#TempFile) for the name of the temporary file. This
can be useful for ensuring syntax highlighting matches your usecase.

```golang
prompt := &survey.Editor{
 Message: "Shell code snippet",
 FileName: "*.sh",
}

survey.AskOne(prompt, &content)
```

## Filtering Options

By default, the user can filter for options in Select and MultiSelects by typing while the prompt
is active. This will filter out all options that don't contain the typed string anywhere in their name, ignoring case.

A custom filter function can also be provided to change this behavior:

```golang
func myFilter(filterValue string, optValue string, optIndex int) bool {
 // only include the option if it includes the filter and has length greater than 5
 return strings.Contains(optValue, filterValue) && len(optValue) >= 5
}

// configure it for a specific prompt
&Select{
 Message: "Choose a color:",
 Options: []string{"red", "blue", "green"},
 Filter: myFilter,
}

// or define a default for all of the questions
survey.AskOne(prompt, &color, survey.WithFilter(myFilter))
```

## Keeping the filter active

By default the filter will disappear if the user selects one of the filtered elements. Once the user selects one element the filter setting is gone.

However the user can prevent this from happening and keep the filter active for multiple selections in a e.g. MultiSelect:

```golang
// configure it for a specific prompt
&Select{
 Message: "Choose a color:",
 Options: []string{"light-green", "green", "dark-green", "red"},
 KeepFilter: true,
}

// or define a default for all of the questions
survey.AskOne(prompt, &color, survey.WithKeepFilter(true))
```

## Validation

Validating individual responses for a particular question can be done by defining a
`Validate` field on the `survey.Question` to be validated. This function takes an
`interface{}` type and returns an error to show to the user, prompting them for another
response. Like usual, validators can be provided directly to the prompt or with `survey.WithValidator`:

```golang
q := &survey.Question{
 Prompt: &survey.Input{Message: "Hello world validation"},
 Validate: func (val interface{}) error {
 // since we are validating an Input, the assertion will always succeed
 if str, ok := val.(string) ; !ok || len(str) > 10 {
 return errors.New("This response cannot be longer than 10 characters.")
 }
	return nil
 },
}

color := ""
prompt := &survey.Input{ Message: "Whats your name?" }

// you can pass multiple validators here and survey will make sure each one passes
survey.AskOne(prompt, &color, survey.WithValidator(survey.Required))
```

### Built-in Validators

`survey` comes prepackaged with a few validators to fit common situations. Currently these
validators include:

| name | valid types | description | notes |
| ------------ | -------------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| Required | any | Rejects zero values of the response type | Boolean values pass straight through since the zero value (false) is a valid response |
| MinLength(n) | string | Enforces that a response is at least the given length | |
| MaxLength(n) | string | Enforces that a response is no longer than the given length | |
| MaxItems(n) | []OptionAnswer | Enforces that a response has no more selections of the indicated | |
| MinItems(n) | []OptionAnswer | Enforces that a response has no less selections of the indicated | |

## Help Text

All of the prompts have a `Help` field which can be defined to provide more information to your users:

<img src="https://thumbs.gfycat.com/CloudyRemorsefulFossa-size_restricted.gif" width="400px" style="margin-top: 8px"/>

```golang
&survey.Input{
 Message: "What is your phone number:",
 Help: "Phone number should include the area code",
}
```

## Removing the "Select All" and "Select None" options

By default, users can select all of the multi-select options using the right arrow key. To prevent users from being able to do this (and remove the `<right> to all` message from the prompt), use the option `WithRemoveSelectAll`:

```golang
import (
 "github.com/AlecAivazis/survey/v2"
)

number := ""
prompt := &survey.Input{
 Message: "This question has the select all option removed",
}

survey.AskOne(prompt, &number, survey.WithRemoveSelectAll())
```

Also by default, users can use the left arrow key to unselect all of the options. To prevent users from being able to do this (and remove the `<left> to none` message from the prompt), use the option `WithRemoveSelectNone`:

```golang
import (
 "github.com/AlecAivazis/survey/v2"
)

number := ""
prompt := &survey.Input{
 Message: "This question has the select all option removed",
}

survey.AskOne(prompt, &number, survey.WithRemoveSelectNone())
```


### Changing the input rune

In some situations, `?` is a perfectly valid response. To handle this, you can change the rune that survey
looks for with `WithHelpInput`:

```golang
import (
 "github.com/AlecAivazis/survey/v2"
)

number := ""
prompt := &survey.Input{
 Message: "If you have this need, please give me a reasonable message.",
 Help: "I couldn't come up with one.",
}

survey.AskOne(prompt, &number, survey.WithHelpInput('^'))
```

## Changing the Icons

Changing the icons and their color/format can be done by passing the `WithIcons` option. The format
follows the patterns outlined [here](https://github.com/mgutz/ansi#style-format). For example:

```golang
import (
 "github.com/AlecAivazis/survey/v2"
)

number := ""
prompt := &survey.Input{
 Message: "If you have this need, please give me a reasonable message.",
 Help: "I couldn't come up with one.",
}

survey.AskOne(prompt, &number, survey.WithIcons(func(icons *survey.IconSet) {
 // you can set any icons
 icons.Question.Text = "⁇"
 // for more information on formatting the icons, see here: https://github.com/mgutz/ansi#style-format
 icons.Question.Format = "yellow+hb"
}))
```

The icons and their default text and format are summarized below:

| name | text | format | description |
| -------------- | ---- | ---------- | ------------------------------------------------------------- |
| Error | X | red | Before an error |
| Help | i | cyan | Before help text |
| Question | ? | green+hb | Before the message of a prompt |
| SelectFocus | > | green | Marks the current focus in `Select` and `MultiSelect` prompts |
| UnmarkedOption | [ ] | default+hb | Marks an unselected option in a `MultiSelect` prompt |
| MarkedOption | [x] | cyan+b | Marks a chosen selection in a `MultiSelect` prompt |

## Custom Types

survey will assign prompt answers to your custom types if they implement this interface:

```golang
type Settable interface {
 WriteAnswer(field string, value interface{}) error
}
```

Here is an example how to use them:

```golang
type MyValue struct {
 value string
}
func (my *MyValue) WriteAnswer(name string, value interface{}) error {
 my.value = value.(string)
}

myval := MyValue{}
survey.AskOne(
 &survey.Input{
 Message: "Enter something:",
 },
 &myval
)
```

## Testing

You can test your program's interactive prompts using [go-expect](https://github.com/Netflix/go-expect). The library
can be used to expect a match on stdout and respond on stdin. Since `os.Stdout` in a `go test` process is not a TTY,
if you are manipulating the cursor or using `survey`, you will need a way to interpret terminal / ANSI escape sequences
for things like `CursorLocation`. `vt10x.NewVT10XConsole` will create a `go-expect` console that also multiplexes
stdio to an in-memory [virtual terminal](https://github.com/hinshun/vt10x).

For some examples, you can see any of the tests in this repo.

## FAQ

### What kinds of IO are supported by `survey`?

survey aims to support most terminal emulators; it expects support for ANSI escape sequences.
This means that reading from piped stdin or writing to piped stdout is **not supported**,
and likely to break your application in these situations. See [#337](https://github.com/AlecAivazis/survey/pull/337#issue-581351617)

### Why isn't Ctrl-C working?

Ordinarily, when you type Ctrl-C, the terminal recognizes this as the QUIT button and delivers a SIGINT signal to the process, which terminates it.
However, Survey temporarily configures the terminal to deliver control codes as ordinary input bytes.
When Survey reads a ^C byte (ASCII \x03, "end of text"), it interrupts the current survey and returns a
`github.com/AlecAivazis/survey/v2/terminal.InterruptErr` from `Ask` or `AskOne`.
If you want to stop the process, handle the returned error in your code:

```go
err := survey.AskOne(prompt, &myVar)
if err != nil {
	if err == terminal.InterruptErr {
		log.Fatal("interrupted")
	}
	...
}
```

survey

ts
===
timestamp convert & compare tool

[![GoDoc](https://godoc.org/github.com/liujianping/ts?status.svg)](https://godoc.org/github.com/liujianping/ts) [![Go Report Card](https://goreportcard.com/badge/github.com/liujianping/ts)](https://goreportcard.com/report/github.com/liujianping/ts) [![Build Status](https://travis-ci.org/liujianping/ts.svg?branch=master)](https://travis-ci.org/liujianping/ts) [![Version](https://img.shields.io/github/tag/liujianping/ts.svg)](https://github.com/liujianping/ts/releases) [![Coverage Status](https://coveralls.io/repos/github/liujianping/ts/badge.svg?branch=master)](https://coveralls.io/github/liujianping/ts?branch=master)

## Install

### Shell Install support Linux & MacOS

````bash
# binary will be $(go env GOPATH)/bin/ts
$: curl -sfL https://raw.githubusercontent.com/liujianping/ts/master/install.sh | sh -s -- -b $(go env GOPATH)/bin

# In alpine linux (as it does not come with curl by default)
$: wget -O - -q https://raw.githubusercontent.com/liujianping/ts/master/install.sh | sh -s 

```` 

### Brew Install only MacOS
````bash
$: brew tap liujianping/tap && brew install ts
````

### Source Install
````bash
$: git clone git@github.com:liujianping/ts.git
$: cd ts
$: go install -mod vendor
````

## Quick Start

````bash
$: ts -h
timestamp convert & compare tool

Usage:
  ts [flags]

Examples:

	(now timestamp)	$: ts
	(now add)		$: ts --add 1d
	(now sub)		$: ts --sub 1d
	(convert)		$: ts "2019/06/24 23:30:10"
	(pipe)			$: echo "2019/06/24 23:30:10" | ts
	(format)		$: ts -f "2019/06/25 23:30:10"
	(before)		$: ts -b "2019/06/25 23:30:10" ; echo $?
	(after)			$: ts -a "2019/06/25 23:30:10" ; echo $?
	(timezone)		$: ts -f "2019/06/25 23:30:10" -z "Asia/Shanghai"
	(Formats)		$: ts -F 
		ANSIC       = "Mon Jan _2 15:04:05 2006"
		UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
		RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
		RFC822      = "02 Jan 06 15:04 MST"
		RFC822Z     = "02 Jan 06 15:04 -0700" RFC822 with numeric zone
		RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
		RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
		RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" RFC1123 with numeric zone
		RFC3339     = "2006-01-02T15:04:05Z07:00"
		RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
		Kitchen     = "3:04PM"
		Stamp      = "Jan _2 15:04:05"
		StampMilli = "Jan _2 15:04:05.000"
		StampMicro = "Jan _2 15:04:05.000000"
		StampNano  = "Jan _2 15:04:05.000000000"
		TimestampSec	= "time.Unix()"
		TimestampMilli  = "time.UnixNano()/1000000"
		TimestampMicro  = "time.UnixNano()/1000"
		TimestampNano	= "time.UnixNano()"

Flags:
      --add duration      add duration
  -a, --after string      after compare
  -b, --before string     before compare
  -f, --format string     time format
  -h, --help              help for ts
      --sub duration      sub duration
  -z, --timezone string   time zone
````

support system format:
- ANSIC       = "Mon Jan _2 15:04:05 2006"
- UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
- RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
- RFC822      = "02 Jan 06 15:04 MST"
- RFC822Z     = "02 Jan 06 15:04 -0700" - RFC822 with numeric zone
- RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
- RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
- RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" - RFC1123 with numeric zone
- RFC3339     = "2006-01-02T15:04:05Z07:00"
- RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
- Kitchen     = "3:04PM"
- Stamp      = "Jan _2 15:04:05"
- StampMilli = "Jan _2 15:04:05.000"
- StampMicro = "Jan _2 15:04:05.000000"
- StampNano  = "Jan _2 15:04:05.000000000"

[![Build Status](https://travis-ci.org/ukautz/clif.svg?branch=master)](https://travis-ci.org/ukautz/clif)
[![GoDoc](https://godoc.org/gopkg.in/ukautz/clif.v1?status.svg)](http://godoc.org/gopkg.in/ukautz/clif.v1)

![logo-large](https://cloud.githubusercontent.com/assets/600604/11909504/c6e25a6e-a5e7-11e5-8eaf-f69fa577b744.png)

Command line interface framework
================================

Go framework for rapid command line application development.

Example
-------

![demo](https://cloud.githubusercontent.com/assets/600604/8886731/c0a517e0-326f-11e5-8349-6ebee2cb8de5.gif)

```go
package main

import "gopkg.in/ukautz/clif.v1"

func main() {
	clif.New("My App", "1.0.0", "An example application").
		New("hello", "The obligatory hello world", func(out clif.Output) {
			out.Printf("Hello World\n")
		}).
		Run()
}
```

- - -



* [Example](#example)
* [Install](#install)
* [Getting started](#getting-started)
* [Commands](#commands)
 * [Callback functions](#callback-functions)
 * [Named](#named)
 * [Default objects](#default-objects)
 * [Arguments and Options](#arguments-and-options)
 * [Arguments](#arguments)
 * [Options](#options)
 * [Flags](#flags)
 * [Validation &amp; (Parsing | Transformation)](#validation--parsing--transformation)
 * [Environment variables &amp; default](#environment-variables--default)
 * [Default options](#default-options)
* [Input &amp; Output](#input--output)
 * [Input](#input)
 * [Ask &amp; AskRegex](#ask--askregex)
 * [Confirm](#confirm)
 * [Choose](#choose)
 * [Output &amp; formatting](#output--formatting)
 * [Output themes](#output-themes)
 * [Styles](#styles)
 * [Table](#table)
 * [Progress bar](#progress-bar)
* [Real-life example](#real-life-example)
* [See also](#see-also)



- - -

Install
-------

``` bash
$ go get gopkg.in/ukautz/clif.v1
```

Getting started
---------------

On the one side, CLIF's *builder*-like API can be easily used for rapid development of small, single purpose tools. On the other side, CLIF is designed with complex console applications in mind.

Commands
--------

Commands must have a unique name and can have additional arguments and options.

``` go
cmd1 := clif.NewCommand("name", "A description", callBackFunction)
cmd2 := clif.NewCommand("other", "Another description", callBackFunction2)
```

The `name` is used from the command line to call the command:

```bash
$ ./app name
$ ./app other
```

### Callback functions

Callback functions can have arbitrary parameters. CLIF uses a small, built-in (signatur) injection container which allows you to register any kind of object (`struct` or `interface`) beforehand.

So you can register any object (interface{}, struct{} .. and anything else, see [below](#named)) in your bootstrap and then "require" those instances by simply putting them in the command callback signature:

```go
// Some type definition
type MyFoo struct {
 X int
}

func main() {
 // init cli
 cli := clif.New("My App", "1.0.0", "An example application")

 // register object instance with container
 foo := &MyFoo{X: 123}
 cli.Register(foo)

 // Create command with callback using the peviously registered instance
 cli.NewCommand("foo", "Call foo", func (foo *MyFoo) {
 // do something with foo
 })

 cli.Run()
}
```

Using interfaces is possible as well, but a bit less elegant:

```go
// Some interface
type MyBar interface {
 Bar() string
}

// Some type
type MyFoo struct {
}

// implement interface
func (m *MyFoo) Bar() string {
 return "bar"
}

func main() {
 // init cli
 cli := clif.New("My App", "1.0.0", "An example application")

 // create object, which implements MyBar:
 foo := &MyFoo{}
 t := reflect.TypeOf((*MyBar)(nil)).Elem()
 cli.RegisterAs(t.String(), foo)

 // Register command with callback using the type
 cli.NewCommand("bar", "Call bar", func (bar MyBar) {
 // do something with bar
 })

 cli.Run()
}
```

#### Named

Everything works great if you only have a single instance of any object of a specific type.
However, if you need more than one instance (which might often be the case for primitive
types, such as `int` or `string`) you can use named registering:

```go
// Register abitrary objects under unique name
cli.RegisterNamed("foo", new(MyFoo)).
 RegisterNamed("bar", 123).
 RegisterNamed("baz", "bla")

// Register command with callback named container
cli.NewCommand("bar", "Call bar", func (named clif.NamedParameters) {
 asMap := map[string]interface{}(named)
 fmt.Println(asMap["baz"].(string))
})
```

**Note**: If you want to use the named feature, you cannot `Register()` any `NamedParameters`
instance yourself, since "normally" registered objects are evaluated before named.

#### Default objects

CLIF pre-populates the dependency container with a couple of built-in objects:

* The `Output` (formatted output helper, see below), eg `func (out clif.Output) { .. }`
* The `Input` (input helper, see below), eg `func (in clif.Input) { .. }`
* The `*Cli` instance itself, eg `func (c *clif.Cli) { .. }`
* The current `*Command` instance, eg `func (o *clif.Command) { .. }`

### Arguments and Options

CLIF can deal with arguments and options. The difference being:

* **Arguments** come after the command name. They are identified by their position.
* **Options** have no fixed position. They are identified by their `--opt-name` (or alias, eg `-O`)

Of course you can use arguments and options at the same time..

#### Arguments

Arguments are additional command line parameters which come after the command name itself.

``` go
cmd := clif.NewCommand("hello", "A description", callBackFunction)
	.NewArgument("name", "Name for greeting", "", true, false)

arg := cmd.NewAgument("other", "Something ..", "default", false, true)
cmd.AddArgument(arg)
```

Arguments consist of a *name*, a *description*, an optional *default* value a *required* flag and a *multiple* flag.

``` bash
$ ./my-app hello the-name other1 other2 other3
# ^ ^ ^ ^ ^
# | | | | |
# | | | | third "other" arg
# | | | second "other" arg
# | | first "other" arg
# | the "name" arg
# command name
```

Position of arguments matters. Make sure you add them in the right order. And: **required** arguments must come before optional arguments (makes sense, right?). There can be only one **multiple** argument at all and, of course, it must be the last (think: variadic).

You can access the arguments by injecting the command instance `*clif.Command` into the callback and calling the `Argument()` method. You can choose to interpret the argument as `String()`, `Int()`, `Float()`, `Bool()`, `Time()` or `Json()`. Multiple arguments can be accessed with `Strings()`, `Ints()` .. and so on. `Count()` gives the amount of (provided) multiple arguments and `Provided()` returns bool for optional arguments. Please see [parameter.go](parameter.go) for more.

``` go
func callbackFunctionI(c *clif.Command) {
	// a single
	name := c.Argument("name").String()

	// a multiple
	others := c.Argument("other").Strings()

	// .. do something ..
}
```

#### Options

Options have no fixed position, meaning `./app --foo --bar` and `./app --bar --foo` are equivalent. Options are referenced by their name (eg `--name`) or alias (eg `-n`). Unless the option is a flag (see below) it must have a value. The value must immediately follow the option. Valid forms are: `--name value`, `--name=value`, `-n value` and `-n=value`.

Options must come before the command, unless they use the `=` separator. For example: `./app command --opt value` is valid, `./app --opt=value command` is valid but `./app --opt value command` is not valid (since it becomes impossible to distinguish between command and value).

``` go
cmd := clif.NewCommand("hello", "A description", callBackFunction)
	.NewOption("name", "n", "Name for greeting", "", true, false)

arg := cmd.NewOption("other", "O", "Something ..", "default", false, true)
cmd.AddOption(arg)
```

Now:

``` bash
$ ./my-app hello --other bar -n Me -O foo
# ^ ^ ^
# | | |
# | | second other opt with value
# | name opt with value
# first other opt with value
```

You can access options the same way as arguments, just use `Option()` instead.

``` go
func callbackFunctionI(c *clif.Command) {
	name := c.Option("name").String()
	others := c.Option("other").Strings()
	// .. do something ..
}
```

##### Flags

There is a special kind of option, which does not expect a parameter: the flag. As options, their position is arbitrary.

``` go
// shorthand
flag := clif.NewFlag("my-flag", "f", "Something ..", false)
// which would just do:
flag = clif.NewOption("my-flag", "f", "Something ..", "", false, false).IsFlag()
cmd := clif.NewCommand("hello", "A description", callBackFunction).AddOption(flag)
```

When using the option, you dont need to (nor can you) provide an argument:

```bash
$ ./my-app hello --my-flag
```

You want to use `Bool()` to check if a flag is provided:

``` go
func callbackFunctionI(c *clif.Command) {
	if c.Option("my-flag").Bool() {
		// ..
	}
}
```

#### Validation & (Parsing | Transformation)

You can validate/parse/transform the input using the `Parse` attribute of options or arguments. It can be (later on)
set using the `SetParse()` method:

``` go
// Validation example
arg := clif.NewArgument("my-int", "An integer", "", true, false).
 SetParse(func(name, value string) (string, error) {
 if _, err := strconv.Atoi(value); err != nil {
 return "", fmt.Errorf("Oops: %s is not an integer: %s", name, err)
 } else {
 return value, nil
 }
 })

// Transformation example
opt := clif.NewOption("client-id", "c", "The client ID", "", true, false).
 SetParse(func(name, value string) (string, error) {
 if strings.Index(value, "#") != 0 {
 return fmt.Sprintf("#%s", value), nil
 } else {
 return value, nil
 }
 })
```

There are a few built-in validators you can use out of the box:

* `clif.IsInt` - Checks for integer, eg `clif.NewOption(..).SetParse(clif.IsInt)`
* `clif.IsFloat` - Checks for float, eg `clif.NewOption(..).SetParse(clif.IsFloat)`

See [validators.go](validators.go).

#### Environment variables & default

The argument and option constructors (`NewArgument`, `NewOption`) already allow you to set a default. In addition you can set
the name of an environment variable, which will be used, if the parameter is not provided.

``` go
opt := clif.NewOption("client-id", "c", "The client ID", "", true, false).SetEnv("CLIENT_ID")
```

The order is:

1. Provided, eg `--config /path/to/config`
2. Environment variable, eg `CONFIG_FILE`
3. Default value, as provided in constructor or set via `SetDefault()`

**Note**: A *required* parameter must have a value, but it does not care whether it came from input, via environment variable or as a default value.

#### Default options

Often you need one or multiple options on every or most commands. The usual `--verbose` or `--config /path..` are common examples.
CLIF provides two ways to deal with those.

1. Modifying/extending `clif.DefaultOptions` (it's pre-filled with the `--help` option, which is `clif.DefaultHelpOption`)
2. Calling `AddDefaultOptions()` or `NewDefaultOption()` on an instance of `clif.Cli`

The former is global (for any instance of `clif.Cli`) and assigned to any new command (created by the `NewCommand` constructor). The latter is applied when `Run()` is called and is in the scope of a single `clif.Cli` instance.

**Note**: A helpful patterns is combining default options and the injection container/registry. Following an example parsing a config file, which can be set on any command with `--config /path..` or as an environment variable and has a default path.

```go

type Conf struct {
 Foo string
 Bar string
}

func() main {

 // init new cli app
 cli := clif.New("my-app", "1.2.3", "My app that does something")

 // register default option, which fills injection container with config instance
 configOpt := clif.NewOption("config", "c", "Path to config file", "/default/config/path.json", true, false).
 SetEnv("MY_APP_CONFIG").
 SetParse(function(name, value string) (string, error) {
 conf := new(Conf)
 if raw, err := ioutil.ReadFile(value); err != nil {
 return "", fmt.Errorf("Could not read config file %s: %s", value, err)
 } else if err = json.Unmarshal(raw, conf); err != nil {
 return "", fmt.Errorf("Could not unmarshal config file %s: %s", value, err)
 } else if conf.Foo == "" {
 return "", fmt.Errorf("Config %s is missing \"foo\"", value)
 } else {
 // register *Conf
 cli.Register(conf)
 return value, nil
 }
 })
 cli.AddDefaultOptions(configOpt)

 // Since *Conf was registered it can be used in any callback
 cli.New("anything", "Does anything", func(conf *Conf) {
 // do something with conf
 })

 cli.Run()
}
```

Input & Output
--------------

Of course, you can just use `fmt` and `os.Stdin`, but for convenience (and fancy output) there are `clif.Output` and `clif.Input`.

### Input

You can inject an instance of the `clif.Input` interface into your command callback. It provides small set of often used tools.

![input](https://cloud.githubusercontent.com/assets/600604/8886968/378a2668-3273-11e5-8bda-51b2b5cd127b.png)

#### Ask & AskRegex

Just ask the user a question then read & check the input. The question will be asked until the check/requirement is satisfied (or the user exits out with `ctrl+c`):

``` go
func callbackFunctionI(in clif.Input) {
	// Any input is OK
	foo := in.Ask("What is a foo", nil)

	// Validate input
	name := in.Ask("Who are you? ", func(v string) error {
		if len(v) > 0 {
			return nil
		} else {
			return fmt.Errorf("Didn't catch that")
		}
	})

	// Shorthand for regex validation
	count := in.AskRegex("How many? ", regexp.MustCompile(`^[0-9]+$`))

	// ..
}
```

*See `clif.RenderAskQuestion` for customization.*

#### Confirm

`Confirm()` ask the user a question until it is answered with `yes` (or `y`) or `no` (or `n`) and returns the response as `bool`.

``` go
func callbackFunctionI(in clif.Input) {
	if in.Confirm("Let's do it?") {
		// ..
	}
}
```

*See `clif.ConfirmRejection`, `clif.ConfirmYesRegex` and `clif.ConfirmNoRegex` for customization.*

#### Choose

`Choose()` is like a select in HTML and provides a list of options with descriptions to the user. The user then must choose (type in) one of the options. The choices will be presented to the user until a valid choice (one of the options) is provided.

``` go
func callbackFunctionI(in clif.Input) {
	father := in.Choose("Who is your father?", map[string]string{
		"yoda": "The small, green guy",
		"darth": "The one with the smoker voice and the dark cape!",
		"obi": "The old man with the light thingy",
	})

	if father == "darth" {
		// ..
	}
}
```

*See `clif.RenderChooseQuestion`, `clif.RenderChooseOption` and `clif.RenderChooseQuery` for customization.*

### Output & formatting

The `clif.Output` interface can be injected into any callback. It relies on a `clif.Formatter`, which does the actual formatting (eg colorizing) of the text.

#### Output themes

Per default, the `clif.DefaultInput` via `clif.NewColorOutput()` is used. It uses `clif.DefaultStyles`, which look like the screenshots you are seeing in this readme.

You can change the output like so:

``` go
cli := clif.New(..)
cli.SetOutput(clif.NewColorOutput().
 SetFormatter(clif.NewDefaultFormatter(clif.SunburnStyles))
```

#### Styles

Styles are applied by parsing (replacing) tokens like `<error>`, which would be substitude with `\033[31;1m` (using the default styles) resulting in a red coloring. Another example is `<reset>`, which is replaced with `\033[0m` leading to reset all colorings & styles.

There three built-in color styles (of course, you can extend them or add your own):

1. `DefaultStyles` - as you can see on this page
1. `SunburnStyles` - more yellow'ish
1. `WinterStyles` - more blue'ish


#### Table

Table rendering is a neat tool for CLIs. CLIF supports tables out of the box using the `Output` interface.

**Features:**

* Multi-line columns
* Column auto fit
* Formatting (color) within columns
* Automatic stretch to max size (unless specifcied otherwise)

**Example:**

``` go
var (
 headers := []string{"Name", "Age", "Force"}
 rows = [][]string{
 {
 "<important>Yoda<reset>",
 "Very, very old",
 "Like the uber guy",
 },
 {
 "<important>Luke Skywalker<reset>",
 "Not that old",
 "A bit, but not that much",
 },
 {
 "<important>Anakin Skywalker<reset>",
 "Old dude",
 "He is Lukes father! Was kind of stronger in 1-3, but still failed to" +
 " kill Jar Jar Binks. Not even tried, though. What's with that?",
 },
	}
)

func callbackFunction(out clif.Output) {
	table := out.Table(headers)
	table.AddRows(rows)
	fmt.Println(table.Render())
}
```

Would print the following:

![table-1](https://cloud.githubusercontent.com/assets/600604/11908046/37aa3578-a5d9-11e5-99a3-cc66937b965c.gif)

There are currently to styles available: `ClosedTableStyle` (above), `ClosedTableStyleLight`, `OpenTableStyle` (below) and `OpenTableStyleLight`:

``` go
func callbackFunction(out clif.Output) {
	table := out.Table(headers, clif.OpenTableStyle)
	table.AddRows(rows)
	fmt.Println(table.Render())
}
```

Would print the following:

![table-2](https://cloud.githubusercontent.com/assets/600604/11908047/37ac10f0-a5d9-11e5-9f95-b7ae59d26ac9.gif)

#### Progress bar

Another often required tool is the progress bar. Hence CLIF provides one out of the box:

```go
func cmdProgress(out clif.Output) error {
	pbs := out.ProgressBars()
	pb, _ := pbs.Init("default", 200)
	pbs.Start()
	var wg sync.WaitGroup
	wg.Add(1)
	go func(b clif.ProgressBar) {
		defer wg.Done()
		for i := 0; i < 200; i++ {
			b.Increment()
			<-time.After(time.Millisecond * 100)
		}
	}(pb)
	wg.Wait()
	<-pbs.Finish()
}
```

Would output this:

![progress-1](https://cloud.githubusercontent.com/assets/600604/11908868/796206c4-a5e0-11e5-9b5b-ffae60f19b99.gif)

Multiple bars are also possible, thanks to [Greg Osuri's library](github.com/gosuri/uilive):

```go
func cmdProgress(out clif.Output) error {
	pbs := out.ProgressBars()
	pbs.Start()
	var wg sync.WaitGroup
	for i := 0; i < 3; i++ {
		wg.Add(1)
		pb, _ := pbs.Init(fmt.Sprintf("bar-%d", i+1), 200)
		go func(b clif.ProgressBar, ii int) {
			defer wg.Done()
			for i := 0; i < 200; i++ {
				b.Increment()
				<-time.After(time.Millisecond * time.Duration(100 * ii))
			}
		}(pb, i)
	}
	wg.Wait()
	<-pbs.Finish()
}
```

Would output this:

![progress-2](https://cloud.githubusercontent.com/assets/600604/11908867/795f1338-a5e0-11e5-8d2c-aa2d8f2802e5.gif)

You prefer those ASCII arrows? Just set `pbs.SetStyle(clif.ProgressBarStyleAscii)` and:

![progress-3](https://cloud.githubusercontent.com/assets/600604/11908964/ac90e83e-a5e1-11e5-8f8a-d3ebaa8c5903.gif)


Real-life example
-----------------

To provide you a usful'ish example, I've written a small CLI application called [repos](https://github.com/ukautz/repos).

See also
--------

There are a lot of [other approaches](https://github.com/avelino/awesome-go#command-line) you should have a look at.

The Best Go Libraries For Command Line - Libraries for building standard or basic Command Line applications. (8)