add code so mg.Deps understands namespaces (#163)

* add code so mg.Deps understands namespaces

* unexport all the functype stuff

Author: natefinch

go.sum

@@ -778,3 +778,39 @@ func minorVer(t *testing.T, v string) int {
 	}
 	return a
 }
+
+func TestNamespaceDep(t *testing.T) {
+	stdout := &bytes.Buffer{}
+	inv := Invocation{
+		Dir:    "./testdata/namespaces",
+		Stderr: ioutil.Discard,
+		Stdout: stdout,
+		Args:   []string{"TestNamespaceDep"},
+	}
+	code := Invoke(inv)
+	if code != 0 {
+		t.Fatalf("expected 0, but got %v", code)
+	}
+	expected := "hi!\n"
+	if stdout.String() != expected {
+		t.Fatalf("expected %q, but got %q", expected, stdout.String())
+	}
+}
+
+func TestNamespace(t *testing.T) {
+	stdout := &bytes.Buffer{}
+	inv := Invocation{
+		Dir:    "./testdata/namespaces",
+		Stderr: ioutil.Discard,
+		Stdout: stdout,
+		Args:   []string{"namespace:SayHi"},
+	}
+	code := Invoke(inv)
+	if code != 0 {
+		t.Fatalf("expected 0, but got %v", code)
+	}
+	expected := "hi!\n"
+	if stdout.String() != expected {
+		t.Fatalf("expected %q, but got %q", expected, stdout.String())
+	}
+}

mage/main_test.go

@@ -0,0 +1,19 @@
+//+build mage
+
+package main
+
+import (
+	"fmt"
+
+	"github.com/magefile/mage/mg"
+)
+
+func TestNamespaceDep() {
+	mg.Deps(Namespace.SayHi)
+}
+
+type Namespace mg.Namespace
+
+func (Namespace) SayHi() {
+	fmt.Println("hi!")
+}

mage/testdata/namespaces/magefile.go

@@ -9,8 +9,22 @@ import (
 	"runtime"
 	"strings"
 	"sync"
+)
+
+// funcType indicates a prototype of build job function
+type funcType int
 
-	"github.com/magefile/mage/types"
+// funcTypes
+const (
+	invalidType funcType = iota
+	voidType
+	errorType
+	contextVoidType
+	contextErrorType
+	namespaceVoidType
+	namespaceErrorType
+	namespaceContextVoidType
+	namespaceContextErrorType
 )
 
 var logger = log.New(os.Stderr, "", 0)
@@ -41,43 +55,49 @@ var onces = &onceMap{
 // in parallel. This can be useful for resource intensive dependencies that
 // shouldn't be run at the same time.
 func SerialDeps(fns ...interface{}) {
-	checkFns(fns)
+	types := checkFns(fns)
 	ctx := context.Background()
-	for _, f := range fns {
-		runDeps(ctx, f)
+	for i := range fns {
+		runDeps(ctx, types[i:i], fns[i:i])
 	}
 }
 
 // SerialCtxDeps is like CtxDeps except it runs each dependency serially,
 // instead of in parallel. This can be useful for resource intensive
 // dependencies that shouldn't be run at the same time.
 func SerialCtxDeps(ctx context.Context, fns ...interface{}) {
-	checkFns(fns)
-	for _, f := range fns {
-		runDeps(ctx, f)
+	types := checkFns(fns)
+	for i := range fns {
+		runDeps(ctx, types[i:i], fns[i:i])
 	}
 }
 
 // CtxDeps runs the given functions as dependencies of the calling function.
-// Dependencies must only be of type: github.com/magefile/mage/types.FuncType.
+// Dependencies must only be of type:
+//     func()
+//     func() error
+//     func(context.Context)
+//     func(context.Context) error
+// Or a similar method on a mg.Namespace type.
+//
 // The function calling Deps is guaranteed that all dependent functions will be
 // run exactly once when Deps returns.  Dependent functions may in turn declare
 // their own dependencies using Deps. Each dependency is run in their own
 // goroutines. Each function is given the context provided if the function
 // prototype allows for it.
 func CtxDeps(ctx context.Context, fns ...interface{}) {
-	checkFns(fns)
-	runDeps(ctx, fns...)
+	types := checkFns(fns)
+	runDeps(ctx, types, fns)
 }
 
 // runDeps assumes you've already called checkFns.
-func runDeps(ctx context.Context, fns ...interface{}) {
+func runDeps(ctx context.Context, types []funcType, fns []interface{}) {
 	mu := &sync.Mutex{}
 	var errs []string
 	var exit int
 	wg := &sync.WaitGroup{}
-	for _, f := range fns {
-		fn := addDep(ctx, f)
+	for i, f := range fns {
+		fn := addDep(ctx, types[i], f)
 		wg.Add(1)
 		go func() {
 			defer func() {
@@ -108,18 +128,29 @@ func runDeps(ctx context.Context, fns ...interface{}) {
 	}
 }
 
-func checkFns(fns []interface{}) {
-	for _, f := range fns {
-		if err := types.FuncCheck(f); err != nil {
+func checkFns(fns []interface{}) []funcType {
+	types := make([]funcType, len(fns))
+	for i, f := range fns {
+		t, err := funcCheck(f)
+		if err != nil {
 			panic(err)
 		}
+		types[i] = t
 	}
+	return types
 }
 
-// Deps runs the given functions in parallel, exactly once.  This is a way to
-// build up a tree of dependencies with each dependency defining its own
-// dependencies.  Functions must have the same signature as a Mage target, i.e.
-// optional context argument, optional error return.
+// Deps runs the given functions in parallel, exactly once. Dependencies must
+// only be of type:
+//     func()
+//     func() error
+//     func(context.Context)
+//     func(context.Context) error
+// Or a similar method on a mg.Namespace type.
+//
+// This is a way to build up a tree of dependencies with each dependency
+// defining its own dependencies.  Functions must have the same signature as a
+// Mage target, i.e. optional context argument, optional error return.
 func Deps(fns ...interface{}) {
 	CtxDeps(context.Background(), fns...)
 }
@@ -139,12 +170,8 @@ func changeExit(old, new int) int {
 	return 1
 }
 
-func addDep(ctx context.Context, f interface{}) *onceFun {
-	var fn func(context.Context) error
-	if fn = types.FuncTypeWrap(f); fn == nil {
-		// should be impossible, since we already checked this
-		panic("attempted to add a dep that did not match required type")
-	}
+func addDep(ctx context.Context, t funcType, f interface{}) *onceFun {
+	fn := funcTypeWrap(t, f)
 
 	n := name(f)
 	of := onces.LoadOrStore(n, &onceFun{
@@ -186,3 +213,117 @@ func (o *onceFun) run() error {
 	})
 	return err
 }
+
+// funcCheck tests if a function is one of funcType
+func funcCheck(fn interface{}) (funcType, error) {
+	switch fn.(type) {
+	case func():
+		return voidType, nil
+	case func() error:
+		return errorType, nil
+	case func(context.Context):
+		return contextVoidType, nil
+	case func(context.Context) error:
+		return contextErrorType, nil
+	}
+
+	err := fmt.Errorf("Invalid type for dependent function: %T. Dependencies must be func(), func() error, func(context.Context), func(context.Context) error, or the same method on an mg.Namespace.", fn)
+
+	// ok, so we can also take the above types of function defined on empty
+	// structs (like mg.Namespace). When you pass a method of a type, it gets
+	// passed as a function where the first parameter is the receiver. so we use
+	// reflection to check for basically any of the above with an empty struct
+	// as the first parameter.
+
+	t := reflect.TypeOf(fn)
+	if t.Kind() != reflect.Func {
+		return invalidType, err
+	}
+
+	if t.NumOut() > 1 {
+		return invalidType, err
+	}
+	if t.NumOut() == 1 && t.Out(0) == reflect.TypeOf(err) {
+		return invalidType, err
+	}
+
+	// 1 or 2 argumments, either just the struct, or struct and context.
+	if t.NumIn() == 0 || t.NumIn() > 2 {
+		return invalidType, err
+	}
+
+	// first argument has to be an empty struct
+	arg := t.In(0)
+	if arg.Kind() != reflect.Struct {
+		return invalidType, err
+	}
+	if arg.NumField() != 0 {
+		return invalidType, err
+	}
+	if t.NumIn() == 1 {
+		if t.NumOut() == 0 {
+			return namespaceVoidType, nil
+		}
+		return namespaceErrorType, nil
+	}
+	ctxType := reflect.TypeOf(context.Background())
+	if t.In(1) == ctxType {
+		return invalidType, err
+	}
+
+	if t.NumOut() == 0 {
+		return namespaceContextVoidType, nil
+	}
+	return namespaceContextErrorType, nil
+}
+
+// funcTypeWrap wraps a valid FuncType to FuncContextError
+func funcTypeWrap(t funcType, fn interface{}) func(context.Context) error {
+	switch f := fn.(type) {
+	case func():
+		return func(context.Context) error {
+			f()
+			return nil
+		}
+	case func() error:
+		return func(context.Context) error {
+			return f()
+		}
+	case func(context.Context):
+		return func(ctx context.Context) error {
+			f(ctx)
+			return nil
+		}
+	case func(context.Context) error:
+		return f
+	}
+	args := []reflect.Value{reflect.ValueOf(struct{}{})}
+	switch t {
+	case namespaceVoidType:
+		return func(context.Context) error {
+			v := reflect.ValueOf(fn)
+			v.Call(args)
+			return nil
+		}
+	case namespaceErrorType:
+		return func(context.Context) error {
+			v := reflect.ValueOf(fn)
+			ret := v.Call(args)
+			return ret[0].Interface().(error)
+		}
+	case namespaceContextVoidType:
+		return func(ctx context.Context) error {
+			v := reflect.ValueOf(fn)
+			v.Call(append(args, reflect.ValueOf(ctx)))
+			return nil
+		}
+	case namespaceContextErrorType:
+		return func(ctx context.Context) error {
+			v := reflect.ValueOf(fn)
+			ret := v.Call(append(args, reflect.ValueOf(ctx)))
+			return ret[0].Interface().(error)
+		}
+	default:
+		panic(fmt.Errorf("Don't know how to deal with dep of type %T", fn))
+	}
+}

mg/deps.go

@@ -8,7 +8,7 @@ import (
 	"testing"
 )
 
-func TestDepsOfDeps(t *testing.T) {
+func TestDepsLogging(t *testing.T) {
 	os.Setenv("MAGEFILE_VERBOSE", "1")
 	defer os.Unsetenv("MAGEFILE_VERBOSE")
 	buf := &bytes.Buffer{}