Fixing default matcher generation

Author: Mattias Öhrn

internal/generate_matchers/matcher_generation.go

@@ -12,51 +12,148 @@ import (
 //     go generate github.com/petergtz/pegomock/internal/generate_matchers
 
 //go:generate go run matcher_generation.go
+//go:generate go fmt ../../matcher_factories.go
+//go:generate go fmt ../../ginkgo_compatible/matchers.go
 
 func main() {
-	err := ioutil.WriteFile(
-		"../../matcher_factories.go",
-		[]byte(GenerateDefaultMatchersFile()),
-		0644)
+	mustWriteFile("../../matcher_factories.go", GenerateDefaultMatchersFile())
+	mustWriteFile("../../ginkgo_compatible/matchers.go", GenerateGinkgoMatchersFile())
+}
+
+func mustWriteFile(path string, contents string) {
+	err := ioutil.WriteFile(path, []byte(contents), 0644)
 	if err != nil {
 		panic(err)
 	}
 }
 
 func GenerateDefaultMatchersFile() string {
-	return fmt.Sprintf(`package pegomock
+	contents := `package pegomock
 
 import (
 	"reflect"
 )
+`
 
-%s
-	`, GenerateDefaultMatchers())
+	for _, kind := range primitiveKinds {
+		contents += fmt.Sprintf(`
+func Eq%[1]s(value %[2]s) %[2]s {
+	RegisterMatcher(&EqMatcher{Value: value})
+	return %[4]s
 }
 
-func GenerateDefaultMatchers() string {
-	result := ""
-	for _, kind := range primitiveKinds {
-		result += GenerateEqMatcherFactory(kind) +
-			GenerateAnyMatcherFactory(kind) +
-			GenerateAnySliceMatcherFactory(kind)
+func NotEq%[1]s(value %[2]s) %[2]s {
+	RegisterMatcher(&NotEqMatcher{Value: value})
+	return %[4]s
+}
+
+func Any%[1]s() %[2]s {
+	RegisterMatcher(NewAnyMatcher(reflect.TypeOf(%[3]s)))
+	return %[4]s
+}
+
+func %[1]sThat(matcher ArgumentMatcher) %[2]s {
+	RegisterMatcher(matcher)
+	return %[4]s
+}
+
+func Eq%[1]sSlice(value []%[2]s) []%[2]s {
+	RegisterMatcher(&EqMatcher{Value: value})
+	return nil
+}
+
+func NotEq%[1]sSlice(value []%[2]s) []%[2]s {
+	RegisterMatcher(&NotEqMatcher{Value: value})
+	return nil
+}
+
+func Any%[1]sSlice() []%[2]s {
+	RegisterMatcher(NewAnyMatcher(reflect.SliceOf(reflect.TypeOf(%[3]s))))
+	return nil
+}
+
+func %[1]sSliceThat(matcher ArgumentMatcher) []%[2]s {
+	RegisterMatcher(matcher)
+	return nil
+}
+`, strings.Title(kind.String()), kind.String(), exampleValue(kind), zeroValue(kind))
 	}
-	// hard-coding this for now as interface{} overall works slighly different than other types.
-	result += `func EqInterface(value interface{}) interface{} {
+
+	// hard-coding this for now as interface{} overall works slightly different than other types.
+	return contents + `
+func EqInterface(value interface{}) interface{} {
 	RegisterMatcher(&EqMatcher{Value: value})
 	return nil
 }
 
+func NotEqInterface(value interface{}) interface{} {
+	RegisterMatcher(&NotEqMatcher{Value: value})
+	return nil
+}
+
 func AnyInterface() interface{} {
-	RegisterMatcher(NewAnyMatcher(reflect.TypeOf((*(interface{}))(nil)).Elem()))
+	RegisterMatcher(NewAnyMatcher(reflect.TypeOf((*interface{})(nil)).Elem()))
+	return nil
+}
+
+func InterfaceThat(matcher ArgumentMatcher) interface{} {
+	RegisterMatcher(matcher)
+	return nil
+}
+
+func EqInterfaceSlice(value []interface{}) []interface{} {
+	RegisterMatcher(&EqMatcher{Value: value})
+	return nil
+}
+
+func NotEqInterfaceSlice(value []interface{}) []interface{} {
+	RegisterMatcher(&NotEqMatcher{Value: value})
 	return nil
 }
 
 func AnyInterfaceSlice() []interface{} {
-	RegisterMatcher(NewAnyMatcher(reflect.SliceOf(reflect.TypeOf((*(interface{}))(nil)).Elem())))
+	RegisterMatcher(NewAnyMatcher(reflect.SliceOf(reflect.TypeOf((*interface{})(nil)).Elem())))
 	return nil
-}`
-	return result
+}
+
+func InterfaceSliceThat(matcher ArgumentMatcher) []interface{} {
+	RegisterMatcher(matcher)
+	return nil
+}
+`
+}
+
+func GenerateGinkgoMatchersFile() string {
+	contents := `package mock
+
+import (
+	"github.com/petergtz/pegomock"
+)
+
+var (`
+
+	for _, kind := range append(primitiveKinds, reflect.Interface) {
+		contents += fmt.Sprintf(`
+	Eq%[1]s = pegomock.Eq%[1]s
+	NotEq%[1]s = pegomock.NotEq%[1]s
+	Any%[1]s = pegomock.Any%[1]s
+	%[1]sThat = pegomock.%[1]sThat
+	Eq%[1]sSlice = pegomock.Eq%[1]sSlice
+	NotEq%[1]sSlice = pegomock.NotEq%[1]sSlice
+	Any%[1]sSlice = pegomock.Any%[1]sSlice
+	%[1]sSliceThat = pegomock.%[1]sSliceThat
+`, strings.Title(kind.String()))
+	}
+
+	return contents + `
+	Times   = pegomock.Times
+	AtLeast = pegomock.AtLeast
+	AtMost  = pegomock.AtMost
+	Never   = pegomock.Never
+	Once    = pegomock.Once
+	Twice   = pegomock.Twice
+)
+`
 }
 
 var primitiveKinds = []reflect.Kind{
@@ -79,38 +176,9 @@ var primitiveKinds = []reflect.Kind{
 	reflect.String,
 }
 
-func GenerateEqMatcherFactory(kind reflect.Kind) string {
-	return fmt.Sprintf(`func Eq%s(value %s) %s {
-	RegisterMatcher(&EqMatcher{Value: value})
-	return %s
-}
-
-`, strings.Title(kind.String()), kind, kind, nullOf(kind))
-}
-
-func GenerateAnyMatcherFactory(kind reflect.Kind) string {
-	return fmt.Sprintf(`func Any%s() %s {
-	RegisterMatcher(NewAnyMatcher(reflect.TypeOf((%s)(%s))))
-	return %s
-}
-
-`, strings.Title(kind.String()), kind, kind.String(), nullOf(kind), nullOf(kind))
-}
-
-func GenerateAnySliceMatcherFactory(kind reflect.Kind) string {
-	return fmt.Sprintf(`func Any%sSlice() []%s {
-	RegisterMatcher(NewAnyMatcher(reflect.SliceOf(reflect.TypeOf((%s)(%s)))))
-	return nil
-}
-
-`, strings.Title(kind.String()), kind.String(), kind.String(), nullOf(kind))
-}
+// TODO generate: chan, func matchers
 
-// TODO generate:
-// Eq Slice matchers
-// generate chan, func matchers
-
-func nullOf(kind reflect.Kind) string {
+func zeroValue(kind reflect.Kind) string {
 	switch {
 	case kind == reflect.Bool:
 		return `false`
@@ -119,6 +187,13 @@ func nullOf(kind reflect.Kind) string {
 	case kind == reflect.String:
 		return `""`
 	default:
-		return "nil"
+		return `nil`
+	}
+}
+
+func exampleValue(kind reflect.Kind) string {
+	if kind == reflect.Bool || kind == reflect.Int || kind == reflect.String {
+		return zeroValue(kind)
 	}
+	return fmt.Sprintf("(%s)(%s)", kind.String(), zeroValue(kind))
 }