# User Guide

While you are welcome to provide your own organization, typically a Cobra-based

application will follow the following organizational structure:

```

  ▾ appName/

    ▾ cmd/

        add.go

        your.go

        commands.go

        here.go

      main.go

```

In a Cobra app, typically the main.go file is very bare. It serves one purpose: initializing Cobra.

```go

package main

import (

  "{pathToYourApp}/cmd"

)

func main() {

  cmd.Execute()

}

```

## Using the Cobra Generator

commands you want. It's the easiest way to incorporate Cobra into your application.

## Using the Cobra Library

To manually implement Cobra you need to create a bare main.go file and a rootCmd file.

You will optionally provide additional commands as you see fit.

### Create rootCmd

Cobra doesn't require any special constructors. Simply create your commands.

Ideally you place this in app/cmd/root.go:

```go

var rootCmd = &cobra.Command{

  Use:   "hugo",

  Short: "Hugo is a very fast static site generator",

  Long: `A Fast and Flexible Static Site Generator built with

                love by spf13 and friends in Go.

  Run: func(cmd *cobra.Command, args []string) {

    // Do Stuff Here

  },

}

func Execute() {

  if err := rootCmd.Execute(); err != nil {

    fmt.Fprintln(os.Stderr, err)

    os.Exit(1)

  }

}

```

You will additionally define flags and handle configuration in your init() function.

For example cmd/root.go:

```go

package cmd

import (

	"fmt"

	"os"

	"github.com/spf13/cobra"

	"github.com/spf13/viper"

)

var (

	// Used for flags.

	cfgFile     string

	userLicense string

	rootCmd = &cobra.Command{

		Short: "A generator for Cobra based Applications",

		Long: `Cobra is a CLI library for Go that empowers applications.

This application is a tool to generate the needed files

to quickly create a Cobra application.`,

	}

)

// Execute executes the root command.

func Execute() error {

	return rootCmd.Execute()

}

func init() {

	cobra.OnInitialize(initConfig)

	rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cobra.yaml)")

	rootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "author name for copyright attribution")

	rootCmd.PersistentFlags().StringVarP(&userLicense, "license", "l", "", "name of license for the project")

	rootCmd.PersistentFlags().Bool("viper", true, "use Viper for configuration")

	viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))

	viper.BindPFlag("useViper", rootCmd.PersistentFlags().Lookup("viper"))

	viper.SetDefault("author", "NAME HERE <EMAIL ADDRESS>")

	viper.SetDefault("license", "apache")

	rootCmd.AddCommand(addCmd)

	rootCmd.AddCommand(initCmd)

}

func initConfig() {

	if cfgFile != "" {

		// Use config file from the flag.

		viper.SetConfigFile(cfgFile)

	} else {

		// Find home directory.

		home, err := os.UserHomeDir()

		cobra.CheckErr(err)

		// Search config in home directory with name ".cobra" (without extension).

		viper.AddConfigPath(home)

		viper.SetConfigType("yaml")

		viper.SetConfigName(".cobra")

	}

	viper.AutomaticEnv()

	if err := viper.ReadInConfig(); err == nil {

		fmt.Println("Using config file:", viper.ConfigFileUsed())

	}

}

```

### Create your main.go

With the root command you need to have your main function execute it.

Execute should be run on the root for clarity, though it can be called on any command.

In a Cobra app, typically the main.go file is very bare. It serves one purpose: to initialize Cobra.

```go

package main

import (

  "{pathToYourApp}/cmd"

)

func main() {

  cmd.Execute()

}

```

### Create additional commands

Additional commands can be defined and typically are each given their own file

inside of the cmd/ directory.

If you wanted to create a version command you would create cmd/version.go and

populate it with the following:

```go

package cmd

import (

  "fmt"

  "github.com/spf13/cobra"

)

func init() {

  rootCmd.AddCommand(versionCmd)

}

var versionCmd = &cobra.Command{

  Use:   "version",

  Short: "Print the version number of Hugo",

  Long:  `All software has versions. This is Hugo's`,

  Run: func(cmd *cobra.Command, args []string) {

    fmt.Println("Hugo Static Site Generator v0.9 -- HEAD")

  },

}

```

### Returning and handling errors

If you wish to return an error to the caller of a command, `RunE` can be used.

```go

package cmd

import (

  "fmt"

  "github.com/spf13/cobra"

)

func init() {

  rootCmd.AddCommand(tryCmd)

}

var tryCmd = &cobra.Command{

  Use:   "try",

  Short: "Try and possibly fail at something",

  RunE: func(cmd *cobra.Command, args []string) error {

    if err := someFunc(); err != nil {

	return err

    }

    return nil

  },

}

```

The error can then be caught at the execute function call.

## Working with Flags

Flags provide modifiers to control how the action command operates.

### Assign flags to a command

Since the flags are defined and used in different locations, we need to

define a variable outside with the correct scope to assign the flag to

work with.

```go

var Verbose bool

var Source string

```

There are two different approaches to assign a flag.

### Persistent Flags

A flag can be 'persistent', meaning that this flag will be available to the

command it's assigned to as well as every command under that command. For

global flags, assign a flag as a persistent flag on the root.

```go

rootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")

```

### Local Flags

A flag can also be assigned locally, which will only apply to that specific command.

```go

localCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from")

```

### Local Flag on Parent Commands

By default, Cobra only parses local flags on the target command, and any local flags on

parent commands are ignored. By enabling `Command.TraverseChildren`, Cobra will

parse local flags on each command before executing the target command.

```go

command := cobra.Command{

  Use: "print [OPTIONS] [COMMANDS]",

  TraverseChildren: true,

}

```

### Bind Flags with Config

You can also bind your flags with [viper](https://github.com/spf13/viper):

```go

var author string

func init() {

  rootCmd.PersistentFlags().StringVar(&author, "author", "YOUR NAME", "Author name for copyright attribution")

  viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))

}

```

In this example, the persistent flag `author` is bound with `viper`.

**Note**: the variable `author` will not be set to the value from config,

More in [viper documentation](https://github.com/spf13/viper#working-with-flags).

### Required flags

Flags are optional by default. If instead you wish your command to report an error

when a flag has not been set, mark it as required:

```go

rootCmd.Flags().StringVarP(&Region, "region", "r", "", "AWS region (required)")

rootCmd.MarkFlagRequired("region")

```

Or, for persistent flags:

```go

rootCmd.PersistentFlags().StringVarP(&Region, "region", "r", "", "AWS region (required)")

rootCmd.MarkPersistentFlagRequired("region")

```

## Positional and Custom Arguments

The following validators are built in:

- `NoArgs` - the command will report an error if there are any positional args.

- `ArbitraryArgs` - the command will accept any args.

- `OnlyValidArgs` - the command will report an error if there are any positional args that are not in the `ValidArgs` field of `Command`.

- `MinimumNArgs(int)` - the command will report an error if there are not at least N positional args.

- `MaximumNArgs(int)` - the command will report an error if there are more than N positional args.

- `ExactArgs(int)` - the command will report an error if there are not exactly N positional args.

- `ExactValidArgs(int)` - the command will report an error if there are not exactly N positional args OR if there are any positional args that are not in the `ValidArgs` field of `Command`

- `RangeArgs(min, max)` - the command will report an error if the number of args is not between the minimum and maximum number of expected args.

An example of setting the custom validator:

```go

var cmd = &cobra.Command{

  Short: "hello",

  Args: func(cmd *cobra.Command, args []string) error {

    if len(args) < 1 {

      return errors.New("requires a color argument")

    }

    if myapp.IsValidColor(args[0]) {

      return nil

    }

    return fmt.Errorf("invalid color specified: %s", args[0])

  },

  Run: func(cmd *cobra.Command, args []string) {

    fmt.Println("Hello, World!")

  },

}

```

## Example

In the example below, we have defined three commands. Two are at the top level

and one (cmdTimes) is a child of one of the top commands. In this case the root

is not executable, meaning that a subcommand is required. This is accomplished

by not providing a 'Run' for the 'rootCmd'.

We have only defined one flag for a single command.

More documentation about flags is available at https://github.com/spf13/pflag

```go

package main

import (

  "fmt"

  "strings"

  "github.com/spf13/cobra"

)

func main() {

  var echoTimes int

  var cmdPrint = &cobra.Command{

    Use:   "print [string to print]",

    Short: "Print anything to the screen",

    Long: `print is for printing anything back to the screen.

For many years people have printed back to the screen.`,

    Args: cobra.MinimumNArgs(1),

    Run: func(cmd *cobra.Command, args []string) {

      fmt.Println("Print: " + strings.Join(args, " "))

    },

  }

  var cmdEcho = &cobra.Command{

    Use:   "echo [string to echo]",

    Short: "Echo anything to the screen",

    Long: `echo is for echoing anything back.

Echo works a lot like print, except it has a child command.`,

    Args: cobra.MinimumNArgs(1),

    Run: func(cmd *cobra.Command, args []string) {

      fmt.Println("Echo: " + strings.Join(args, " "))

    },

  }

  var cmdTimes = &cobra.Command{

    Use:   "times [string to echo]",

    Short: "Echo anything to the screen more times",

    Long: `echo things multiple times back to the user by providing

a count and a string.`,

    Args: cobra.MinimumNArgs(1),

    Run: func(cmd *cobra.Command, args []string) {

      for i := 0; i < echoTimes; i++ {

        fmt.Println("Echo: " + strings.Join(args, " "))

      }

    },

  }

  cmdTimes.Flags().IntVarP(&echoTimes, "times", "t", 1, "times to echo the input")

  var rootCmd = &cobra.Command{Use: "app"}

  rootCmd.AddCommand(cmdPrint, cmdEcho)

  cmdEcho.AddCommand(cmdTimes)

  rootCmd.Execute()

}

```

## Help Command

Cobra automatically adds a help command to your application when you have subcommands.

This will be called when a user runs 'app help'. Additionally, help will also