refactor arg parsing; add -f force flag

Author: clipperhouse

config.go

@@ -10,11 +10,13 @@ import (
 type config struct {
 	out        io.Writer
 	customName string
+	*typewriter.Config
 }
 
 var defaultConfig = config{
 	out:        os.Stdout,
 	customName: "_gen.go",
+	Config:     &typewriter.Config{},
 }
 
 // keep in sync with imports.go

main.go

@@ -2,6 +2,7 @@
 package main
 
 import (
+	"fmt"
 	"os"
 	"regexp"
 )
@@ -26,16 +27,17 @@ var exitStatusMsg = regexp.MustCompile(`^exit status \d+$`)
 func runMain(args []string) error {
 	c := defaultConfig
 
-	if len(args) == 1 {
-		// simply typed 'gen'; run is the default command
-		return run(c)
+	cmd, force, tail, err := parseArgs(args)
+
+	if err != nil {
+		return err
 	}
 
-	cmd := args[1]
+	c.IgnoreTypeCheckErrors = force
 
-	var tail []string
-	if len(args) > 2 {
-		tail = args[2:]
+	if len(cmd) == 0 {
+		// simply typed 'gen'; run is the default command
+		return run(c)
 	}
 
 	switch cmd {
@@ -51,3 +53,44 @@ func runMain(args []string) error {
 		return help(c)
 	}
 }
+
+var s = struct{}{}
+
+var cmds = map[string]struct{}{
+	"add":   s,
+	"get":   s,
+	"help":  s,
+	"list":  s,
+	"watch": s,
+}
+
+func parseArgs(args []string) (cmd string, force bool, tail []string, err error) {
+	for _, a := range args[1:] { // arg[0] is 'gen'
+		if _, ok := cmds[a]; ok {
+			if len(cmd) > 0 {
+				err = fmt.Errorf("more than one command specified; type gen help for usage")
+				break
+			}
+			cmd = a
+			continue
+		}
+		if a == "-f" {
+			force = true
+			continue
+		}
+		tail = append(tail, a)
+	}
+
+	// tail is only valid on add & get; otherwise an error
+	if len(tail) > 0 && cmd != "add" && cmd != "get" {
+		err = fmt.Errorf("unknown command(s) %v", tail)
+		tail = []string{}
+	}
+
+	// force flag is only valid with run & watch
+	if force && cmd != "" && cmd != "watch" {
+		err = fmt.Errorf("-f flag is not valid with %q", cmd)
+	}
+
+	return cmd, force, tail, err
+}

main_test.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+type parseTest struct {
+	text  string
+	cmd   string
+	force bool
+	tail  int  //length
+	err   bool //exists
+}
+
+func TestParseArgs(t *testing.T) {
+	tests := []parseTest{
+		parseTest{"gen", "", false, 0, false},
+		parseTest{"gen -f", "", true, 0, false},
+		parseTest{"gen yadda", "", false, 0, true}, // unknown command
+		parseTest{"gen -bar", "", false, 0, true},  // tail is not ok
+		parseTest{"gen add", "add", false, 0, false},
+		parseTest{"gen add foo bar", "add", false, 2, false}, // tail is ok
+		parseTest{"gen add -f", "add", true, 0, true},        // force is not ok
+		parseTest{"gen get", "get", false, 0, false},
+		parseTest{"gen get foo bar", "get", false, 2, false}, // tail is ok
+		parseTest{"gen get -f", "get", true, 0, true},        // force is not ok
+		parseTest{"gen help", "help", false, 0, false},
+		parseTest{"gen help foo bar", "help", false, 0, true}, // tail is not ok
+		parseTest{"gen help -f", "help", true, 0, true},       // force is not ok
+		parseTest{"gen list", "list", false, 0, false},
+		parseTest{"gen list foo bar", "list", false, 0, true}, // tail is not ok
+		parseTest{"gen list -f", "list", true, 0, true},       // force is not ok
+		parseTest{"gen watch", "watch", false, 0, false},
+		parseTest{"gen watch foo bar", "watch", false, 0, true}, // tail is not ok
+		parseTest{"gen watch -f", "watch", true, 0, false},      // force is ok
+	}
+
+	for i, test := range tests {
+		cmd, force, tail, err := parseArgs(strings.Split(test.text, " "))
+		if cmd != test.cmd {
+			t.Errorf("tests[%d]: cmd should be %q, got %q", i, test.cmd, cmd)
+		}
+		if force != test.force {
+			t.Errorf("tests[%d]: force should be %v, got %v", i, test.force, force)
+		}
+		if len(tail) != test.tail {
+			t.Errorf("tests[%d]: len(tail) should be %v, got %v", i, test.tail, len(tail))
+		}
+		if (err != nil) != test.err {
+			t.Errorf("tests[%d]: err existence should be %v, got %v", i, test.err, err)
+		}
+	}
+}