Cli api (#2)

* Add flagIterator
* Add Cli wrapper
* Add SetSwitch utility method

- add newCliError
- add builder pattern to Flagset
- FlagSet.isFlag -> FlagSet.hasFlag
- Fix setAsParsed bug on booleans
- rename flag setter methods to Set<Type>(), fs.SetInt("n")
- rename flag getter methods to <Type>(), fs.Int("n")

Author: Gers2017

demo/demo.go

@@ -28,65 +28,58 @@ func (t *Todo) String() string {
 }
 
 func main() {
-	get := flago.NewFlagSet("get")
-	get.Bool("all", false)
-	get.Bool("reverse", false)
-	get.Str("sort-by", "title")
-	get.Str("by-title", "")
-	get.Bool("primary", false)
-	get.Bool("help", false)
+	get := flago.NewFlagSet("get").
+		SetSwitch("all"). // SetSwitch shorthand for SetBool(<flagname>, false)
+		SetBool("reverse", false).
+		SetStr("sort-by", "title").
+		SetStr("by-title", "").
+		SetBool("primary", false).
+		SetSwitch("help") // Optional, cli adds a help flag if none was provided
 
 	args := os.Args
-	if len(args) <= 2 {
-		fmt.Println(GET_CMD_HELP)
-		return
-	}
 
-	action := args[1]
-	args_to_parse := args[2:]
 	todos := []Todo{
 		{"foo", "describes foo", 3, false},
 		{"bar", "describes bar", 8, false},
-		{"yeet", "describes yeet", 2, false},
-		{"boo", "describes boo", 7, true},
+		{"yeet", "describes yeet", 12, false},
+		{"boo", "describes boo", 9, true},
 	}
 
-	if action != get.Name {
-		fmt.Printf("Invalid action %s\n", action)
-		fmt.Println(GET_CMD_HELP)
-		return
-	}
+	cli := flago.NewCli()
+	cli.Handle(get, func(fs *flago.FlagSet) error {
+		HandleGet(fs, todos)
+		return nil
+	})
 
-	if err := get.ParseFlags(args_to_parse); err != nil {
+	if err := cli.Execute(args); err != nil {
 		fmt.Println(err)
-		return
 	}
+}
 
-	if get.IsParsed("all") {
-
-		HandleAll(get, todos)
-
-	} else if get.IsParsed("by-title") {
-
-		HandleByTitle(get, todos)
-
-	} else if get.IsParsed("primary") {
-
-		HandleByPrimary(get, todos)
-
+func HandleGet(fs *flago.FlagSet, todos []Todo) {
+	isAll := fs.IsParsed("all")
+	isByTitle := fs.IsParsed("by-title")
+	isPrimary := fs.IsParsed("primary")
+
+	if isAll {
+		HandleAll(fs, todos)
+	} else if isByTitle {
+		HandleByTitle(fs, todos)
+	} else if isPrimary {
+		HandleByPrimary(fs, todos)
 	} else {
 		fmt.Println(GET_CMD_HELP)
 	}
 }
 
 func HandleAll(fs *flago.FlagSet, todos []Todo) {
-	if fs.GetBool("help") {
+	if fs.Bool("help") {
 		fmt.Println(GET_ALL_HELP)
 		return
 	}
 
-	is_reverse := fs.GetBool("reverse")
-	sort_by := fs.GetStr("sort-by")
+	is_reverse := fs.Bool("reverse")
+	sort_by := fs.Str("sort-by")
 
 	if sort_by == "title" {
 		sort.Slice(todos, func(i, j int) bool {
@@ -110,20 +103,20 @@ func HandleAll(fs *flago.FlagSet, todos []Todo) {
 }
 
 func HandleByTitle(fs *flago.FlagSet, todos []Todo) {
-	if fs.GetBool("help") {
+	if fs.Bool("help") {
 		fmt.Println(GET_BY_TITLE_HELP)
 		return
 	}
 
-	title := fs.GetStr("by-title")
-	title = strings.ToLower(title)
+	title := strings.ToLower(fs.Str("by-title"))
 	filtered := make([]Todo, 0)
 
 	for _, todo := range todos {
 		if strings.ToLower(todo.title) == title {
 			filtered = append(filtered, todo)
 		}
 	}
+
 	if len(filtered) > 0 {
 		fmt.Println(filtered[0].String())
 	} else {
@@ -132,7 +125,7 @@ func HandleByTitle(fs *flago.FlagSet, todos []Todo) {
 }
 
 func HandleByPrimary(fs *flago.FlagSet, todos []Todo) {
-	if fs.GetBool("help") {
+	if fs.Bool("help") {
 		fmt.Println(GET_PRIMARY_HELP)
 		return
 	}

errors.go

@@ -1,16 +1,23 @@
 package flago
 
 import (
-	"errors"
 	"fmt"
 )
 
 func newParseTypeError(value, datatype string) error {
-	return errors.New(fmt.Sprintf("Error at parsing value \"%s\" to datatype %s\n", value, datatype))
+	return fmt.Errorf("Error at parsing value \"%s\" to datatype %s\n", value, datatype)
 }
 
 func newUnknownDataTypeError(datatype, name string) error {
-	return errors.New(fmt.Sprintf("Unexpected datatype \"%s\" for flag of name %s", datatype, name))
+	return fmt.Errorf("Unexpected datatype \"%s\" for flag of name %s", datatype, name)
+}
+
+func newMissingValueError(name string, i int) error {
+	return fmt.Errorf("The key: %s is trying to access missing item at index: %d", name, i)
+}
+
+func newCliError(cli *Cli) error {
+	return fmt.Errorf("Available Subcommands: %v", cli.flagsetKeys())
 }
 
 type invalidFlagAsValueError struct {

flago.go

@@ -1,76 +1,102 @@
 package flago
 
-func (fs *FlagSet) ParseFlags(args_to_parse []string) error {
-	args_copy := copySlice(args_to_parse)
+func (fs *FlagSet) ParseFlags(args []string) error {
+	cp := copySlice(args)
 
 	// remove flag prefix from args
-	for i, v := range args_copy {
-		args_copy[i] = removeFlagPrefix(v)
+	for i, v := range cp {
+		cp[i] = removeFlagPrefix(v)
 	}
 
-	// get the tokens from args
-	tokens := getTokens(args_copy)
+	args = cp
 
-	// filter by flag names
-	only_flags := make([]token, 0)
-	for _, token := range tokens {
-		if fs.isFlag(token.name) {
-			only_flags = append(only_flags, token)
+	iter := newFlagIterator(args)
+	for !iter.is_empty() {
+		key, ok := iter.next()
+		if !fs.hasFlag(key) || !ok {
+			continue
 		}
-	}
-
-	tokens = only_flags
 
-	// parse tokens into flag
-	for _, token := range tokens {
-		name := token.name
-		value := token.value
-		flag := fs.Flags[name]
+		flag := fs.Flags[key]
+		data_type := flag.Datatype
 
-		if flag.Datatype != "bool" && fs.isFlag(value) && value != "help" {
-			return newInvalidFlagAsValueError(name, value)
-		}
-
-		switch flag.Datatype {
-		case "bool":
+		if data_type == "bool" {
 			flag.Value = true
-		case "string":
-			flag.Value = value
-		case "int":
-			v, err := parseInt(value)
-			if err != nil {
-				return newParseTypeError(value, "int")
+		} else {
+			value, ok := iter.next()
+			if !ok {
+				return newMissingValueError(key, iter.index)
 			}
 
-			flag.Value = v
-
-		case "float":
-			v, err := parseFloat(value)
-			if err != nil {
-				return newParseTypeError(value, "float")
+			if fs.hasFlag(value) && value != "help" {
+				return newInvalidFlagAsValueError(key, value)
 			}
 
-			flag.Value = v
+			switch data_type {
+			case "string":
+				flag.Value = value
 
-		default:
-			return newUnknownDataTypeError(string(flag.Datatype), flag.Name)
+			case "int":
+				int_value, err := parseInt(value)
+				if err != nil {
+					return newParseTypeError(value, "int")
+				}
+
+				flag.Value = int_value
+
+			case "float":
+				float_value, err := parseFloat(value)
+				if err != nil {
+					return newParseTypeError(value, "float")
+				}
+
+				flag.Value = float_value
+
+			default:
+				return newUnknownDataTypeError(string(data_type), flag.Name)
+			}
 		}
-		fs.setAsParsed(name)
+
+		fs.setAsParsed(key)
 	}
 
 	return nil
 }
 
-type token = struct {
-	name  string
-	value string
+type flagIterator struct {
+	args  []string
+	index int
+	max   int
+}
+
+func newFlagIterator(args []string) flagIterator {
+	index := 0
+	max := len(args)
+	return flagIterator{args, index, max}
 }
 
-func getTokens(args []string) []token {
-	tokens := make([]token, 0)
-	for i := range args {
-		tokens = append(tokens, token{name: getArg(args, i), value: getArg(args, i+1)})
+func (fi *flagIterator) next() (string, bool) {
+	if fi.is_empty() {
+		return "", false
 	}
 
-	return tokens
+	s := fi.args[fi.index]
+	fi.index += 1
+	return s, true
+}
+
+func (fi *flagIterator) next_range(n int) ([]string, bool) {
+	res := []string{}
+	for i := 0; i < n; i++ {
+		ch, ok := fi.next()
+		if !ok {
+			return res, false
+		}
+		res = append(res, ch)
+	}
+	return res, true
+}
+
+func (fi *flagIterator) is_empty() bool {
+	return fi.index >= fi.max
 }