Refactor builtins and func calls

Author: antonmedv

eval.go

@@ -3,6 +3,7 @@ package expr
 import (
 	"fmt"
 	"math"
+	"reflect"
 	"regexp"
 )
 
@@ -297,25 +298,51 @@ func (n methodNode) Eval(env interface{}) (interface{}, error) {
 		return nil, err
 	}
 
-	return call(n.method, method, n.arguments, env)
-}
+	in := make([]reflect.Value, 0)
 
-func (n builtinNode) Eval(env interface{}) (interface{}, error) {
-	if len(n.arguments) == 0 {
-		return nil, fmt.Errorf("missing argument to %v", n.name)
+	for _, a := range n.arguments {
+		i, err := a.Eval(env)
+		if err != nil {
+			return nil, err
+		}
+		in = append(in, reflect.ValueOf(i))
 	}
-	if len(n.arguments) > 1 {
-		return nil, fmt.Errorf("too many arguments to %v: %v", n.name, n)
+
+	out := reflect.ValueOf(method).Call(in)
+
+	if len(out) == 0 {
+		return nil, nil
+	} else if len(out) > 1 {
+		return nil, fmt.Errorf("method %q must return only one value", n.method)
 	}
 
-	a, err := n.arguments[0].Eval(env)
-	if err != nil {
-		return nil, err
+	if out[0].IsValid() && out[0].CanInterface() {
+		return out[0].Interface(), nil
 	}
 
+	return nil, nil
+}
+
+func (n builtinNode) Eval(env interface{}) (interface{}, error) {
 	switch n.name {
 	case "len":
-		return count(n.arguments[0], a)
+		if len(n.arguments) == 0 {
+			return nil, fmt.Errorf("missing argument: %v", n)
+		}
+		if len(n.arguments) > 1 {
+			return nil, fmt.Errorf("too many arguments: %v", n)
+		}
+
+		i, err := n.arguments[0].Eval(env)
+		if err != nil {
+			return nil, err
+		}
+
+		switch reflect.TypeOf(i).Kind() {
+		case reflect.Array, reflect.Slice, reflect.String:
+			return float64(reflect.ValueOf(i).Len()), nil
+		}
+		return nil, fmt.Errorf("invalid argument %v (type %T)", n, i)
 	}
 
 	return nil, fmt.Errorf("unknown %q builtin", n.name)
@@ -327,7 +354,29 @@ func (n functionNode) Eval(env interface{}) (interface{}, error) {
 		return nil, err
 	}
 
-	return call(n.name, fn, n.arguments, env)
+	in := make([]reflect.Value, 0)
+
+	for _, a := range n.arguments {
+		i, err := a.Eval(env)
+		if err != nil {
+			return nil, err
+		}
+		in = append(in, reflect.ValueOf(i))
+	}
+
+	out := reflect.ValueOf(fn).Call(in)
+
+	if len(out) == 0 {
+		return nil, nil
+	} else if len(out) > 1 {
+		return nil, fmt.Errorf("func %q must return only one value", n.name)
+	}
+
+	if out[0].IsValid() && out[0].CanInterface() {
+		return out[0].Interface(), nil
+	}
+
+	return nil, nil
 }
 
 func (n conditionalNode) Eval(env interface{}) (interface{}, error) {

eval_test.go

@@ -413,19 +413,19 @@ var evalErrorTests = []evalErrorTest{
 		"operator in not defined on string",
 	},
 	{
-		"len(1)",
+		"len()",
 		nil,
-		"invalid argument 1 (type float64) for len",
+		"missing argument: len()",
 	},
 	{
-		"len(foo, bar)",
-		map[string]interface{}{"foo": nil, "bar": nil},
-		"too many arguments to len: len(foo, bar)",
+		"len(1)",
+		nil,
+		"invalid argument len(1) (type float64)",
 	},
 	{
-		"len()",
+		"len(a, b)",
 		nil,
-		"missing argument to len",
+		"too many arguments: len(a, b)",
 	},
 }
 

type.go

@@ -166,8 +166,10 @@ func (n builtinNode) Type(table typesTable) (Type, error) {
 			return nil, err
 		}
 	}
-	if _, ok := builtins[n.name]; ok {
-		return interfaceType, nil
+	switch n.name {
+	case "len":
+		// TODO: Add arguments type checks.
+		return numberType, nil
 	}
 	return nil, fmt.Errorf("%v undefined", n)
 }

utils.go

@@ -112,41 +112,3 @@ func contains(needle interface{}, array interface{}) (bool, error) {
 	}
 	return false, nil
 }
-
-func count(node Node, array interface{}) (float64, error) {
-	if array != nil {
-		value := reflect.ValueOf(array)
-		switch reflect.TypeOf(array).Kind() {
-		case reflect.Array, reflect.Slice:
-			return float64(value.Len()), nil
-		case reflect.String:
-			return float64(value.Len()), nil
-		}
-		return 0, fmt.Errorf("invalid argument %v (type %T) for len", node, array)
-	}
-
-	return 0, nil
-}
-
-func call(name string, fn interface{}, arguments []Node, env interface{}) (interface{}, error) {
-	in := make([]reflect.Value, 0)
-	for _, arg := range arguments {
-		a, err := Run(arg, env)
-		if err != nil {
-			return nil, err
-		}
-		in = append(in, reflect.ValueOf(a))
-	}
-
-	out := reflect.ValueOf(fn).Call(in)
-	if len(out) == 0 {
-		return nil, nil
-	} else if len(out) > 1 {
-		return nil, fmt.Errorf("func %q must return only one value", name)
-	}
-
-	if out[0].IsValid() && out[0].CanInterface() {
-		return out[0].Interface(), nil
-	}
-	return nil, nil
-}