Refactor the code to be cleaner.

This refactors the entire lot so that it can act as a library in the future, and as a command if used directly.  This also increases test coverage considerably... there is still more testing to do though.

Author: envygeeks

flags.go

@@ -8,24 +8,36 @@ import (
 	"flag"
 )
 
-type BoolSlice []interface{}
+type BoolArg []interface{}
 type Args map[string]interface{}
-type StringSlice []interface{}
-type IntSlice []interface{}
-type ArgSlice []interface{}
-
-var (
-	_cliFlags = ArgSlice{
-		StringSlice{"file", "", "the file, or dir"},
-		BoolSlice{"glob", false, "search, and use a dir full of *.gohtml"},
-		StringSlice{"output", "", "the file to write to"},
-		BoolSlice{"stdout", false, "print to stdout"},
+type StringArg []interface{}
+type Flags []interface{}
+
+// Bool pulls a value as a boolean, this
+// supports *bool, and bool, because either
+// can be given depending on flags
+func (a Args) Bool(k string) bool {
+	o, ok := a[k].(bool)
+	if ok {
+		return o
 	}
-)
 
-func (a Args) Bool(k string) bool     { return bool(*a[k].(*bool)) }
-func (a Args) String(k string) string { return string(*a[k].(*string)) }
-func (a Args) Int(k string) int       { return int(*a[k].(*int)) }
+	v := *a[k].(*bool)
+	return bool(v)
+}
+
+// String pulls a value as a boolean, this
+// supports *bool, and bool, because either
+// can be given depending on flags
+func (a Args) String(k string) string {
+	o, ok := a[k].(string)
+	if ok {
+		return o
+	}
+
+	v := *a[k].(*string)
+	return string(v)
+}
 
 // IsEmpty Allows you to check if a value was
 // given, this means that it wasn't nil, that it
@@ -38,30 +50,55 @@ func (a Args) IsEmpty(k string) bool {
 	return false
 }
 
-// flags parses our flags, and returns them
+// NewFlags provides the default flags, and
+// allows somebody who wishes to use as a base to
+// add their own flags, by just append()
+func NewFlags() *Flags {
+	return &Flags{
+		StringArg{"file", "", "the file, or dir"},
+		BoolArg{"glob", false, "search, and use a dir full of *.gohtml"},
+		StringArg{"output", "", "the file to write to"},
+		BoolArg{"stdout", false, "print to stdout"},
+		BoolArg{"debug", false, "debug output"},
+	}
+}
+
+// Parse parses our flags, and returns them,
 // we just encapsulate this to make life a little
 // easier at the end of the day, when working.
-func flags() (a Args) {
-	a = make(map[string]interface{})
-	for _, v := range _cliFlags {
+func (f Flags) Parse() (a Args) {
+	a = make(Args)
+	for _, v := range f {
 		switch v.(type) {
-		case BoolSlice:
-			vv := v.(BoolSlice)
-			a[vv[0].(string)] = flag.Bool(vv[0].(string),
-				vv[1].(bool), vv[2].(string))
-
-		case StringSlice:
-			vv := v.(StringSlice)
-			a[vv[0].(string)] = flag.String(vv[0].(string),
-				vv[1].(string), vv[2].(string))
-
-		case IntSlice:
-			vv := v.(IntSlice)
-			a[vv[0].(string)] = flag.Int(vv[0].(string),
-				vv[1].(int), vv[2].(string))
+		case BoolArg:
+			vv := v.(BoolArg)
+			k, def, dsc := vv[0].(string), vv[1].(bool), vv[2].(string)
+			if flag.Lookup(k) == nil {
+				a[k] = flag.Bool(k, def, dsc)
+				continue
+			}
+
+			fv := flag.Lookup(k).Value
+			ov := fv.(flag.Getter).Get()
+			a[k] = ov.(bool)
+
+		case StringArg:
+			vv := v.(StringArg)
+			k, def, dsc := vv[0].(string), vv[1].(string), vv[2].(string)
+			if flag.Lookup(k) == nil {
+				a[k] = flag.String(k, def, dsc)
+				continue
+			}
+
+			fv := flag.Lookup(k).Value
+			ov := fv.(flag.Getter).Get()
+			a[k] = ov.(string)
 		}
 	}
 
-	flag.Parse()
+	if !flag.Parsed() {
+		flag.Parse()
+	}
+
 	return
 }

flags_test.go

@@ -10,13 +10,51 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestIsEmpty(t *testing.T) {
+func TestNewFlags(t *testing.T) {
+	assert.NotEmpty(t, NewFlags())
+}
+
+func TestFlags_Parse(t *testing.T) {
+	a := NewFlags().Parse()
+	assert.IsType(t,
+		Args{}, a)
+}
+
+func TestArgs_Bool(t *testing.T) {
+	for _, v := range [][3]interface{}{
+		{&[]bool{false}[0], false, "it's false when false"},
+		{&[]bool{true}[0], true, "it's true when true"},
+	} {
+		a := Args{"k": v[0]}
+		assert.IsType(t, a.Bool("k"), v[1], v[2])
+	}
+}
+
+func TestArgs_String(t *testing.T) {
+	for _, v := range [][3]interface{}{
+		{&[]string{""}[0], "", "it's false when false"},
+	} {
+		a := Args{"k": v[0]}
+		assert.IsType(t, a.String("k"), v[1], v[2])
+	}
+}
+
+// func TestArgs_Int(t *testing.T) {
+// 	for _, v := range [][3]interface{}{
+// 		{&[]int{1}[0], 1, "it's false when false"},
+// 	} {
+// 		a := Args{"k": v[0]}
+// 		assert.IsType(t, a.Int("k"), v[1], v[2])
+// 	}
+// }
+
+func TestArgs_IsEmpty(t *testing.T) {
 	for _, v := range [][3]interface{}{
 		{nil, true, "is true on nil"},
 		{"string", false, "it false on non-empty string"},
 		{"", true, "it true on \"\""},
 	} {
-		args := Args{"k": v[0]}
-		assert.Equal(t, args.IsEmpty("k"), v[1], v[2])
+		a := Args{"k": v[0]}
+		assert.Equal(t, a.IsEmpty("k"), v[1], v[2])
 	}
 }

funcs.go

@@ -9,80 +9,70 @@ import (
 	"strconv"
 	"strings"
 	"text/template"
-)
 
-type BoolFunc func(s string) bool
-type BoolFuncWithError func(s string) (bool, error)
-type StringFuncWithError func(s string) (string, error)
-type IntFuncWithError func(s string) (int, error)
-type StringFunc func(s string) string
-type IntFunc func(s string) int
+	log "github.com/sirupsen/logrus"
+)
 
 // func_trimStr trims a string for you... obviously
-func func_trimStr(t *template.Template) StringFunc {
-	return func(s string) string {
-		return strings.TrimSpace(s)
-	}
+func (t *Template) _trimStr(s string) string {
+	return strings.TrimSpace(s)
 }
 
 // func_templateExists allows you to check if a
 // template exists inside of the templates, this also
 // works for context based {{ define "name" }}.
-func func_templateExists(t *template.Template) BoolFunc {
-	return func(s string) bool {
-		if tt := t.Lookup(s); tt != nil {
-			return true
-		}
-
-		return false
+func (t *Template) _templateExists(s string) bool {
+	log.Debugf("looking for template %s", s)
+	if tt := t.template.Lookup(s); tt != nil {
+		return true
 	}
+
+	return false
 }
 
 // func_eExists allows you to check if a var exists
 // in your current environment, we do not alter it so
 // make sure you use FULLCAP if necessary.
-func func_eExists(t *template.Template) BoolFunc {
-	return func(s string) bool {
-		_, ok := os.LookupEnv(s)
-		return ok
-	}
+func (t *Template) _eExists(s string) bool {
+	_, ok := os.LookupEnv(s)
+	log.Debugf("checked if env %s exists", s)
+	return ok
 }
 
 // func_eStr allows you to pull out a string env var
-func func_eStr(t *template.Template) StringFunc {
-	return func(s string) string {
-		if v, ok := os.LookupEnv(s); ok {
-			return v
-		}
-
-		return ""
+func (t *Template) _eStr(s string) string {
+	if v, ok := os.LookupEnv(s); ok {
+		return v
 	}
+
+	return ""
 }
 
 // func_eBool allows you to pull out a env var as a
 // bool, following the same rules as strconv.ParseBool
 // where 1, true are true, and all else is false
-func func_eBool(t *template.Template) BoolFuncWithError {
-	return func(s string) (bool, error) {
-		if v, ok := os.LookupEnv(s); ok {
-			vv, err := strconv.ParseBool(v)
-			if err != nil {
-				return false, err
-			}
-
-			return vv, nil
+func (t *Template) _eBool(s string) (bool, error) {
+	if v, ok := os.LookupEnv(s); ok {
+		vv, err := strconv.ParseBool(v)
+		if err != nil {
+			return false, err
 		}
 
-		return false, nil
+		return vv, nil
 	}
+
+	return false, nil
 }
 
-func funcs(t *template.Template) template.FuncMap {
-	return template.FuncMap{
-		"eBool":          func_eBool(t),
-		"templateExists": func_templateExists(t),
-		"eExists":        func_eExists(t),
-		"trimStr":        func_trimStr(t),
-		"eStr":           func_eStr(t),
-	}
+// setupFuncs attaches the funcs to the template
+func (t *Template) addFuncs() *Template {
+	t.template.Funcs(template.FuncMap{
+		"eBool":          t._eBool,
+		"templateExists": t._templateExists,
+		"eExists":        t._eExists,
+		"trimStr":        t._trimStr,
+		"eStr":           t._eStr,
+	})
+
+	return t
 }