Add map checker

Author: cwchentw

README.md

@@ -14,11 +14,11 @@ import (
 	"log"
 )
 
-var checker *ov.Checker
+var checker *ov.ListChecker
 
 func init() {
 	// Expect (int, int) or (float64, float64)
-	checker = ov.NewChecker(
+	checker = ov.NewListChecker(
 		ov.NewRule(
 			ov.NewArgument("int"),
 			ov.NewArgument("int")),
@@ -63,11 +63,11 @@ import (
 	"log"
 )
 
-var checker *ov.Checker
+var checker *ov.ListChecker
 
 func init() {
 	// Expect (int, int) or (int)
-	checker = ov.NewChecker(
+	checker = ov.NewListChecker(
 		ov.NewRule(
 			ov.NewArgument("int"),
 			ov.NewArgument("int", 3)))

argument.go

@@ -1,8 +1,9 @@
 package overloading
 
 type Argument struct {
-	_type    string
-	_default interface{}
+	_type      string
+	isOptional bool
+	_default   interface{}
 }
 
 func NewArgument(args ...interface{}) *Argument {
@@ -23,6 +24,7 @@ func NewArgument(args ...interface{}) *Argument {
 	p._type = arr[0].(string)
 
 	if len(arr) == 2 {
+		p.isOptional = true
 		p._default = arr[1]
 	}
 
@@ -34,7 +36,7 @@ func (a *Argument) Type() string {
 }
 
 func (a *Argument) IsOptional() bool {
-	return a._default != nil
+	return a.isOptional
 }
 
 func (a *Argument) Default() interface{} {

checker.go list_checker.go

@@ -1,11 +1,11 @@
 package overloading
 
-type Checker struct {
+type ListChecker struct {
 	rules []*Rule
 }
 
-func NewChecker(rules ...*Rule) *Checker {
-	c := new(Checker)
+func NewListChecker(rules ...*Rule) *ListChecker {
+	c := new(ListChecker)
 	c.rules = make([]*Rule, len(rules))
 
 	for i, r := range rules {
@@ -15,7 +15,7 @@ func NewChecker(rules ...*Rule) *Checker {
 	return c
 }
 
-func (c *Checker) Check(args []interface{}) []interface{} {
+func (c *ListChecker) Check(args []interface{}) []interface{} {
 	for _, r := range c.rules {
 		out, err := r.Check(args)
 		if err == nil {

checker_test.go list_checker_test.go

@@ -9,7 +9,7 @@ func TestChecker(t *testing.T) {
 	t.Parallel()
 
 	// Expect (int, int)
-	c := NewChecker(
+	c := NewListChecker(
 		NewRule(
 			NewArgument("int"),
 			NewArgument("int")))
@@ -37,7 +37,7 @@ func TestCheckerViolation(t *testing.T) {
 	}()
 
 	// Expect (int, int)
-	c := NewChecker(
+	c := NewListChecker(
 		NewRule(
 			NewArgument("int"),
 			NewArgument("int")))
@@ -58,7 +58,7 @@ func TestMultiRuleChecker(t *testing.T) {
 	t.Parallel()
 
 	// Expect (int, int) or (float64, float64)
-	c := NewChecker(
+	c := NewListChecker(
 		NewRule(
 			NewArgument("int"),
 			NewArgument("int")),

rule.go list_rule.go

@@ -0,0 +1,27 @@
+package overloading
+
+type MapChecker struct {
+	rules []*MapRule
+}
+
+func NewMapChecker(args ...*MapRule) *MapChecker {
+	m := new(MapChecker)
+	m.rules = make([]*MapRule, len(args))
+
+	for i, a := range args {
+		m.rules[i] = a
+	}
+
+	return m
+}
+
+func (m *MapChecker) Check(args map[string]interface{}) map[string]interface{} {
+	for _, r := range m.rules {
+		out, err := r.Check(args)
+		if err == nil {
+			return out
+		}
+	}
+
+	panic("No valid argument")
+}

rule_test.go list_rule_test.go

@@ -0,0 +1,48 @@
+package overloading
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestMapChecker(t *testing.T) {
+	c := NewMapChecker(
+		NewMapRule(
+			"x", NewArgument("int"),
+			"y", NewArgument("int")),
+		NewMapRule(
+			"x", NewArgument("float64"),
+			"y", NewArgument("float64")))
+
+	f := func(arg map[string]interface{}) interface{} {
+		out := c.Check(arg)
+
+		t := reflect.TypeOf(out["x"]).String()
+		switch t {
+		case "int":
+			na := out["x"].(int)
+			nb := out["y"].(int)
+			return na + nb
+		case "float64":
+			na := out["x"].(float64)
+			nb := out["y"].(float64)
+			return na + nb
+		default:
+			panic("Unknown type")
+		}
+	}
+
+	arg1 := make(map[string]interface{})
+	arg1["x"] = 3
+	arg1["y"] = 2
+	if f(arg1).(int) != 5 {
+		t.Error("Wrong map checker")
+	}
+
+	arg2 := make(map[string]interface{})
+	arg2["x"] = 3.0
+	arg2["y"] = 2.0
+	if f(arg2).(float64) != 5.0 {
+		t.Error("Wrong map checker")
+	}
+}

map_checker.go

@@ -0,0 +1,57 @@
+package overloading
+
+import (
+	"errors"
+	"reflect"
+)
+
+type MapRule struct {
+	m map[string]*Argument
+}
+
+func NewMapRule(args ...interface{}) *MapRule {
+	_len := len(args)
+	if _len%2 != 0 {
+		panic("Wrong argument length")
+	}
+	r := new(MapRule)
+	r.m = make(map[string]*Argument)
+
+	for i := 0; i < _len; i += 2 {
+		k := args[i].(string)
+		r.m[k] = args[i+1].(*Argument)
+	}
+
+	return r
+}
+
+func (r *MapRule) Check(args map[string]interface{}) (map[string]interface{}, error) {
+	out := make(map[string]interface{})
+
+	for k, v := range args {
+		arg, ok := r.m[k]
+		if !ok {
+			return out, errors.New("Unknown argument " + k)
+		}
+
+		t := reflect.TypeOf(v).String()
+		if t != arg.Type() {
+			return out, errors.New("Wrong argument type on " + k)
+		}
+
+		out[k] = v
+	}
+
+	for k := range r.m {
+		_, ok := args[k]
+		if !ok {
+			if r.m[k].IsOptional() {
+				out[k] = r.m[k].Default()
+			} else {
+				return out, errors.New("No default value on " + k)
+			}
+		}
+	}
+
+	return out, nil
+}

map_checker_test.go

@@ -0,0 +1,58 @@
+package overloading
+
+import "testing"
+
+func TestMapRule(t *testing.T) {
+	t.Parallel()
+	r := NewMapRule(
+		"x", NewArgument("int"),
+		"y", NewArgument("int", 3))
+
+	f := func(arg map[string]interface{}) int {
+		out, err := r.Check(arg)
+		if err != nil {
+			t.Error("The argument should be correct")
+		}
+
+		na := out["x"].(int)
+		nb := out["y"].(int)
+
+		return na + nb
+	}
+
+	args := make(map[string]interface{})
+	args["x"] = 3
+
+	n := f(args)
+	if n != 6 {
+		t.Error("Wrong rule")
+	}
+}
+
+func TestMapRuleViolation(t *testing.T) {
+	t.Parallel()
+
+	r := NewMapRule(
+		"x", NewArgument("int"),
+		"y", NewArgument("int", 3))
+
+	f := func(arg map[string]interface{}) int {
+		out, err := r.Check(arg)
+		if err == nil {
+			t.Error("The argument should be wrong")
+		} else {
+			return 0
+		}
+
+		na := out["x"].(int)
+		nb := out["y"].(int)
+
+		return na + nb
+	}
+
+	args := make(map[string]interface{})
+	args["x"] = 3
+	args["z"] = 5
+
+	_ = f(args)
+}