added usage generation

parse.go

@@ -1,17 +1,28 @@
-package arguments
+package arg
 
 import (
 	"fmt"
-	"log"
 	"os"
 	"reflect"
 	"strconv"
 	"strings"
 )
 
+// spec represents a command line option
+type spec struct {
+	dest       reflect.Value
+	long       string
+	short      string
+	multiple   bool
+	required   bool
+	positional bool
+	help       string
+	wasPresent bool
+}
+
 // MustParse processes command line arguments and exits upon failure.
-func MustParse(dest interface{}) {
-	err := Parse(dest)
+func MustParse(dest ...interface{}) {
+	err := Parse(dest...)
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
@@ -19,122 +30,121 @@ func MustParse(dest interface{}) {
 }
 
 // Parse processes command line arguments and stores the result in args.
-func Parse(dest interface{}) error {
-	return ParseFrom(dest, os.Args)
+func Parse(dest ...interface{}) error {
+	return ParseFrom(os.Args[1:], dest...)
 }
 
 // ParseFrom processes command line arguments and stores the result in args.
-func ParseFrom(dest interface{}, args []string) error {
-	v := reflect.ValueOf(dest)
-	if v.Kind() != reflect.Ptr {
-		panic(fmt.Sprintf("%s is not a pointer type", v.Type().Name()))
+func ParseFrom(args []string, dest ...interface{}) error {
+	// Add the help option if one is not already defined
+	var internal struct {
+		Help bool `arg:"-h"`
 	}
-	v = v.Elem()
 
 	// Parse the spec
-	spec, err := extractSpec(v.Type())
+	dest = append(dest, &internal)
+	spec, err := extractSpec(dest...)
 	if err != nil {
 		return err
 	}
 
 	// Process args
-	err = processArgs(v, spec, args)
+	err = processArgs(spec, args)
 	if err != nil {
 		return err
 	}
 
+	// If -h or --help were specified then print help
+	if internal.Help {
+		writeUsage(os.Stdout, spec)
+		os.Exit(0)
+	}
+
 	// Validate
 	return validate(spec)
 }
 
-// spec represents information about an argument extracted from struct tags
-type spec struct {
-	field      reflect.StructField
-	index      int
-	long       string
-	short      string
-	multiple   bool
-	required   bool
-	positional bool
-	help       string
-	wasPresent bool
-}
-
 // extractSpec gets specifications for each argument from the tags in a struct
-func extractSpec(t reflect.Type) ([]*spec, error) {
-	if t.Kind() != reflect.Struct {
-		panic(fmt.Sprintf("%s is not a struct pointer", t.Name()))
-	}
-
+func extractSpec(dests ...interface{}) ([]*spec, error) {
 	var specs []*spec
-	for i := 0; i < t.NumField(); i++ {
-		// Check for the ignore switch in the tag
-		field := t.Field(i)
-		tag := field.Tag.Get("arg")
-		if tag == "-" {
-			continue
+	for _, dest := range dests {
+		v := reflect.ValueOf(dest)
+		if v.Kind() != reflect.Ptr {
+			panic(fmt.Sprintf("%s is not a pointer (did you forget an ampersand?)", v.Type()))
 		}
-
-		spec := spec{
-			long:  strings.ToLower(field.Name),
-			field: field,
-			index: i,
+		v = v.Elem()
+		if v.Kind() != reflect.Struct {
+			panic(fmt.Sprintf("%T is not a struct pointer", dest))
 		}
 
-		// Get the scalar type for this field
-		scalarType := field.Type
-		log.Println(field.Name, field.Type, field.Type.Kind())
-		if scalarType.Kind() == reflect.Slice {
-			spec.multiple = true
-			scalarType = scalarType.Elem()
-			if scalarType.Kind() == reflect.Ptr {
-				scalarType = scalarType.Elem()
+		t := v.Type()
+		for i := 0; i < t.NumField(); i++ {
+			// Check for the ignore switch in the tag
+			field := t.Field(i)
+			tag := field.Tag.Get("arg")
+			if tag == "-" {
+				continue
 			}
-		}
 
-		// Check for unsupported types
-		switch scalarType.Kind() {
-		case reflect.Array, reflect.Chan, reflect.Func, reflect.Interface,
-			reflect.Map, reflect.Ptr, reflect.Struct,
-			reflect.Complex64, reflect.Complex128:
-			return nil, fmt.Errorf("%s.%s: %s fields are not supported", t.Name(), field.Name, scalarType.Kind())
-		}
+			spec := spec{
+				long: strings.ToLower(field.Name),
+				dest: v.Field(i),
+			}
 
-		// Look at the tag
-		if tag != "" {
-			for _, key := range strings.Split(tag, ",") {
-				var value string
-				if pos := strings.Index(key, ":"); pos != -1 {
-					value = key[pos+1:]
-					key = key[:pos]
+			// Get the scalar type for this field
+			scalarType := field.Type
+			if scalarType.Kind() == reflect.Slice {
+				spec.multiple = true
+				scalarType = scalarType.Elem()
+				if scalarType.Kind() == reflect.Ptr {
+					scalarType = scalarType.Elem()
 				}
+			}
+
+			// Check for unsupported types
+			switch scalarType.Kind() {
+			case reflect.Array, reflect.Chan, reflect.Func, reflect.Interface,
+				reflect.Map, reflect.Ptr, reflect.Struct,
+				reflect.Complex64, reflect.Complex128:
+				return nil, fmt.Errorf("%s.%s: %s fields are not supported", t.Name(), field.Name, scalarType.Kind())
+			}
+
+			// Look at the tag
+			if tag != "" {
+				for _, key := range strings.Split(tag, ",") {
+					var value string
+					if pos := strings.Index(key, ":"); pos != -1 {
+						value = key[pos+1:]
+						key = key[:pos]
+					}
 
-				switch {
-				case strings.HasPrefix(key, "--"):
-					spec.long = key[2:]
-				case strings.HasPrefix(key, "-"):
-					if len(key) != 2 {
-						return nil, fmt.Errorf("%s.%s: short arguments must be one character only", t.Name(), field.Name)
+					switch {
+					case strings.HasPrefix(key, "--"):
+						spec.long = key[2:]
+					case strings.HasPrefix(key, "-"):
+						if len(key) != 2 {
+							return nil, fmt.Errorf("%s.%s: short arguments must be one character only", t.Name(), field.Name)
+						}
+						spec.short = key[1:]
+					case key == "required":
+						spec.required = true
+					case key == "positional":
+						spec.positional = true
+					case key == "help":
+						spec.help = value
+					default:
+						return nil, fmt.Errorf("unrecognized tag '%s' on field %s", key, tag)
 					}
-					spec.short = key[1:]
-				case key == "required":
-					spec.required = true
-				case key == "positional":
-					spec.positional = true
-				case key == "help":
-					spec.help = value
-				default:
-					return nil, fmt.Errorf("unrecognized tag '%s' on field %s", key, tag)
 				}
 			}
+			specs = append(specs, &spec)
 		}
-		specs = append(specs, &spec)
 	}
 	return specs, nil
 }
 
 // processArgs processes arguments using a pre-constructed spec
-func processArgs(dest reflect.Value, specs []*spec, args []string) error {
+func processArgs(specs []*spec, args []string) error {
 	// construct a map from --option to spec
 	optionMap := make(map[string]*spec)
 	for _, spec := range specs {
@@ -192,7 +202,7 @@ func processArgs(dest reflect.Value, specs []*spec, args []string) error {
 			} else {
 				values = append(values, value)
 			}
-			err := setSlice(dest.Field(spec.index), values)
+			err := setSlice(spec.dest, values)
 			if err != nil {
 				return fmt.Errorf("error processing %s: %v", arg, err)
 			}
@@ -200,7 +210,7 @@ func processArgs(dest reflect.Value, specs []*spec, args []string) error {
 		}
 
 		// if it's a flag and it has no value then set the value to true
-		if spec.field.Type.Kind() == reflect.Bool && value == "" {
+		if spec.dest.Kind() == reflect.Bool && value == "" {
 			value = "true"
 		}
 
@@ -213,7 +223,7 @@ func processArgs(dest reflect.Value, specs []*spec, args []string) error {
 			i++
 		}
 
-		err := setScalar(dest.Field(spec.index), value)
+		err := setScalar(spec.dest, value)
 		if err != nil {
 			return fmt.Errorf("error processing %s: %v", arg, err)
 		}
@@ -221,22 +231,21 @@ func processArgs(dest reflect.Value, specs []*spec, args []string) error {
 
 	// process positionals
 	for _, spec := range specs {
-		label := strings.ToLower(spec.field.Name)
 		if spec.positional {
 			if spec.multiple {
-				err := setSlice(dest.Field(spec.index), positionals)
+				err := setSlice(spec.dest, positionals)
 				if err != nil {
-					return fmt.Errorf("error processing %s: %v", label, err)
+					return fmt.Errorf("error processing %s: %v", spec.long, err)
 				}
 				positionals = nil
 			} else if len(positionals) > 0 {
-				err := setScalar(dest.Field(spec.index), positionals[0])
+				err := setScalar(spec.dest, positionals[0])
 				if err != nil {
-					return fmt.Errorf("error processing %s: %v", label, err)
+					return fmt.Errorf("error processing %s: %v", spec.long, err)
 				}
 				positionals = positionals[1:]
 			} else if spec.required {
-				return fmt.Errorf("%s is required", label)
+				return fmt.Errorf("%s is required", spec.long)
 			}
 		}
 	}
@@ -250,7 +259,7 @@ func processArgs(dest reflect.Value, specs []*spec, args []string) error {
 func validate(spec []*spec) error {
 	for _, arg := range spec {
 		if !arg.positional && arg.required && !arg.wasPresent {
-			return fmt.Errorf("--%s is required", strings.ToLower(arg.field.Name))
+			return fmt.Errorf("--%s is required", arg.long)
 		}
 	}
 	return nil

parse_test.go

@@ -1,4 +1,4 @@
-package arguments
+package arg
 
 import (
 	"strings"
@@ -16,7 +16,7 @@ func TestStringSingle(t *testing.T) {
 	var args struct {
 		Foo string
 	}
-	err := ParseFrom(&args, split("--foo bar"))
+	err := ParseFrom(split("--foo bar"), &args)
 	require.NoError(t, err)
 	assert.Equal(t, "bar", args.Foo)
 }
@@ -30,7 +30,7 @@ func TestMixed(t *testing.T) {
 		Spam float32
 	}
 	args.Bar = 3
-	err := ParseFrom(&args, split("123 -spam=1.2 -ham -f xyz"))
+	err := ParseFrom(split("123 -spam=1.2 -ham -f xyz"), &args)
 	require.NoError(t, err)
 	assert.Equal(t, "xyz", args.Foo)
 	assert.Equal(t, 3, args.Bar)
@@ -43,7 +43,7 @@ func TestRequired(t *testing.T) {
 	var args struct {
 		Foo string `arg:"required"`
 	}
-	err := ParseFrom(&args, nil)
+	err := ParseFrom(nil, &args)
 	require.Error(t, err, "--foo is required")
 }
 
@@ -52,15 +52,15 @@ func TestShortFlag(t *testing.T) {
 		Foo string `arg:"-f"`
 	}
 
-	err := ParseFrom(&args, split("-f xyz"))
+	err := ParseFrom(split("-f xyz"), &args)
 	require.NoError(t, err)
 	assert.Equal(t, "xyz", args.Foo)
 
-	err = ParseFrom(&args, split("-foo xyz"))
+	err = ParseFrom(split("-foo xyz"), &args)
 	require.NoError(t, err)
 	assert.Equal(t, "xyz", args.Foo)
 
-	err = ParseFrom(&args, split("--foo xyz"))
+	err = ParseFrom(split("--foo xyz"), &args)
 	require.NoError(t, err)
 	assert.Equal(t, "xyz", args.Foo)
 }
@@ -71,7 +71,7 @@ func TestCaseSensitive(t *testing.T) {
 		Upper bool `arg:"-V"`
 	}
 
-	err := ParseFrom(&args, split("-v"))
+	err := ParseFrom(split("-v"), &args)
 	require.NoError(t, err)
 	assert.True(t, args.Lower)
 	assert.False(t, args.Upper)
@@ -83,7 +83,7 @@ func TestCaseSensitive2(t *testing.T) {
 		Upper bool `arg:"-V"`
 	}
 
-	err := ParseFrom(&args, split("-V"))
+	err := ParseFrom(split("-V"), &args)
 	require.NoError(t, err)
 	assert.False(t, args.Lower)
 	assert.True(t, args.Upper)
@@ -94,7 +94,7 @@ func TestPositional(t *testing.T) {
 		Input  string `arg:"positional"`
 		Output string `arg:"positional"`
 	}
-	err := ParseFrom(&args, split("foo"))
+	err := ParseFrom(split("foo"), &args)
 	require.NoError(t, err)
 	assert.Equal(t, "foo", args.Input)
 	assert.Equal(t, "", args.Output)
@@ -105,7 +105,7 @@ func TestRequiredPositional(t *testing.T) {
 		Input  string `arg:"positional"`
 		Output string `arg:"positional,required"`
 	}
-	err := ParseFrom(&args, split("foo"))
+	err := ParseFrom(split("foo"), &args)
 	assert.Error(t, err)
 }
 
@@ -114,7 +114,7 @@ func TestTooManyPositional(t *testing.T) {
 		Input  string `arg:"positional"`
 		Output string `arg:"positional"`
 	}
-	err := ParseFrom(&args, split("foo bar baz"))
+	err := ParseFrom(split("foo bar baz"), &args)
 	assert.Error(t, err)
 }
 
@@ -123,7 +123,7 @@ func TestMultiple(t *testing.T) {
 		Foo []int
 		Bar []string
 	}
-	err := ParseFrom(&args, split("--foo 1 2 3 --bar x y z"))
+	err := ParseFrom(split("--foo 1 2 3 --bar x y z"), &args)
 	require.NoError(t, err)
 	assert.Equal(t, []int{1, 2, 3}, args.Foo)
 	assert.Equal(t, []string{"x", "y", "z"}, args.Bar)