params

Params-Go

This package provides a simple Parser that can parse a sequence of arguments, for instande command line arguments. However, it can parse any parameters given.

Purpose

This a just a programmatic exercise for me where I try to implement a package with a simple API for handling command line arguments.

Usage

The usage is best demonstrated with examples.

Non-positional arguments

Non-positional arguments are those which are provided with dashes followed by a name, e.g. --myarg 10 and is either string or int type. The argument can the be used in the following ways:

prog --myarg <val>	# argument name and value separated by space
prog --myarg=<val>	# argument name and value separated by =
prog -myarg=<val>	# same as above, only with one dash

These can be created by using the AddString and AddInt functions, respectively:

parser := params.NewParser()
var strArg string
var intArg int

parser.AddString(&strArg, "str", "my default string value", "a string arg")
parser.AddInt(&intArg, "int", 666, "an int arg")
parser.Parse()

As you can see, you provide a pointer to the variable which you want to set.

Options are just specified as, well, an option, and requires no value. They are always false by default.

parser := params.NewParser()
var boolArg bool
parser.AddOption(&boolArg, "myopt", "my special flag")

Positional arguments

Positional arguments can be added using the AddPosString function. Positional arguments currently have the following limitations:

• Are always required
• Only type string
• The order of the calls to AddPosString determines the order of the arguments (i.e the positional arguments are expected in that order)

Just the like other functions AddPosString first takes a pointer to the variable which should be set followed by the name and description.

parser := params.NewParser()
var pos string
parser.AddPosString(&pos, "pos1", "positional arg")

Alias

You can give arguments an alias by specifying a single letter as the last parameter on any Add_ function:

parser := params.NewParser()
var arg string
parser.AddPosString(&arg, "marg", "defval", "some arg", "m")

Example

The following example demonstrate how to parse command line arguments.

parser := params.NewParser()
var strArg string
var intArg int
var option bool
var posArg string

parser.AddString(&strArg, "mystr", "my default string value", "a string arg", "s")
parser.AddInt(&intArg, "myint", 1234, "an int arg")
parser.AddOption(&option, "myopt", "an option")
parser.AddPosString(&posArg, "pos", "a positional arg")

parser.Name("gnarg-demo")
parser.Description("A demo of this fantastic (?) Go package")

err := parser.Parse() // Must be called to process the arguments
if err != nil {
      panic(err)
}

fmt.Println("Value of the string argument:", strArg)
fmt.Println("Value of the int argument:", intArg)
fmt.Println("Value of the option:", option)
fmt.Println("Value of the positional argument:", posArg)

fmt.Println("Remaining arguments after parse:", parser.Args())

$ ./gnarg --myint=1337 pos-arg-val -s=lol
Value of the string argument: lol
Value of the int argument: 1337
Value of the option: false
Value of the positional argument: pos-arg-val
Remaining arguments after parse: []

Help

params.-go also provide a -h/--help flag that prints a classic usage text. For instance, the program above would print the following:

$ ./params --help
Usage: demo pos [-h/--help] [-s/--mystr[=]MYSTR] [--myint[=]MYINT] [--myopt]

A demo of this sheety (?) Go package
                pos    a positional arg
          -h/--help    Displays this message
 -s/--mystr[=]MYSTR    a string arg
    --myint[=]MYINT    an int arg
            --myopt    an option