Parsing command line arguments in Go

Question

I've written a reimplementation of the redis-benchmark in Go and part of that is parsing options from the command line. I evaluated several libraries but nothing I found seem to do what I had in mind.

Here is the code:

// ParseArguments parses a string array and returns a populated Options struct
func ParseArguments(arguments []string) Options {
    options := defaultOptions

    args := arguments[1:]
    var errOptions Options
    for i := 0; i < len(args); i++ {
        if args[i] == "--help" || args[i] == "-h" {
            return Options{ShowHelp: true, HelpText: helpText}
        } else if args[i] == "--host" || args[i] == "-H" {
            i++
            if i >= len(args) {
                return buildHelp("Error: Incorrect parameters specified")
            }
            options.Host = args[i]
        } else if args[i] == "--requests" || args[i] == "-n" {
            options.Requests, errOptions = parseNumber(args, &i)
            if errOptions.ShowHelp {
                return errOptions
            }
        } else if args[i] == "--clients" || args[i] == "-c" {
            options.Connections, errOptions = parseNumber(args, &i)
            if errOptions.ShowHelp {
                return errOptions
            }
        } else if args[i] == "--tests" || args[i] == "-t" {
            i++
            if i >= len(args) {
                return buildHelp("Error: Incorrect parameters specified")
            }
            options.Tests = strings.Split(args[i], ",")
            for i := range options.Tests {
                options.Tests[i] = strings.ToUpper(options.Tests[i])
            }
        } else if args[i] == "--port" || args[i] == "-p" {
            options.Port, errOptions = parseNumber(args, &i)
            if errOptions.ShowHelp {
                return errOptions
            }
        } else {
            return buildHelp(fmt.Sprintf("Error: Invalid parameter: %v", args[i]))
        }
    }

    return options
}

(For more context, the rest of the file is on github).

When gocyclo is run over the code the function gets a complexity of 20. I'm interested in suggestions that could reduce this to below the threshold of 10.

Answer 1

You should definitely rely on a library to achieve this. The flag package from standard library is nice, but go-flags is even better

With this library, the equivalent code is:

package main

import (
    "fmt"
    "os"

    "github.com/jessevdk/go-flags"
)

type options struct {
    Help     bool     `short:"h" long:"help" description:"show help message"`
    Requests int      `short:"n" long:"requests" default:"1"`
    Clients  int      `short:"c" long:"clients" default:"1"`
    Tests    []string `short:"t" long:"tests" env-delim:","`
    Port     int      `short:"p" long:"port" default:"9000"`
}

func main() {
    var opts options
    p := flags.NewParser(&opts, flags.Default&^flags.HelpFlag)
    _, err := p.Parse()
    if err != nil {
        fmt.Printf("fail to parse args: %v", err)
        os.Exit(1)
    }
    if opts.Help {
        p.WriteHelp(os.Stdout)
        os.Exit(0)
    }
    fmt.Printf("tests: %v\n", opts)
}

All errors (type error, required flag missing ect...) are handle directly by the library

Now the complexity of the function is 3

Answer 2

You can do all this just fine with the standard library. The only tricky bit is the CSV format for --tests (consider using []string directly, and let the caller specify multiple -t/--tests arguments). I had to guess the Options type, but it should be obvious how to change it for, say, uints.

package main

import (
    "flag"
    "fmt"
    "strings"
)

type Options struct {
    Requests    int
    Connections int
    Tests       []string
    Port        int
}

func main() {
    options := ParseArguments([]string{"-c", "10", "--requests", "20", "-t", "foo,bar"})

    fmt.Printf("%+v\n", options)
    // {Requests:20 Connections:10 Tests:[FOO BAR] Port:0}
}

func ParseArguments(arguments []string) Options {
    var defaultOptions Options
    options := defaultOptions

    fs := flag.NewFlagSet("main", flag.ExitOnError)

    fs.IntVar(&options.Requests, "requests", defaultOptions.Requests, "requests description")
    fs.IntVar(&options.Requests, "n", defaultOptions.Requests, "requests description")

    fs.IntVar(&options.Connections, "clients", defaultOptions.Connections, "clients description")
    fs.IntVar(&options.Connections, "c", defaultOptions.Connections, "clients description")

    fs.IntVar(&options.Port, "port", defaultOptions.Port, "port description")
    fs.IntVar(&options.Port, "p", defaultOptions.Port, "port description")

    tests := csv{}
    fs.Var(&tests, "tests", "tests description")
    fs.Var(&tests, "t", "tests description")

    fs.Parse(arguments)
    options.Tests = tests

    return options
}

type csv []string

func (vs *csv) String() string {
    return strings.Join(*vs, ",")
}
func (vs *csv) Set(arg string) error {
    values := strings.Split(arg, ",")
    for i := range values {
            values[i] = strings.ToUpper(values[i])
    }

    *vs = values // or append(), if repeated args are okay
    return nil
}

https://play.golang.org/p/bqNgCt63QL