Adds support for common operators for time.Time (#256)

* adds support for common operators for time.Time

* adds eval tests for time operators. updates checker to allow time.Time and time.Duration to be passed to the operator fns.

* allows duration to be the first arg in time addition. updates the checker return types as they were incorrect.

* add ability to compare time to any interface

* adds checker test for time + interface combinations

Author: panthershark

checker/checker.go

@@ -208,6 +208,9 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 		if isComparable(l, r) {
 			return boolType
 		}
+		if isTime(l) && isTime(r) {
+			return boolType
+		}
 
 	case "or", "||", "and", "&&":
 		if isBool(l) && isBool(r) {
@@ -232,8 +235,19 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 		if isString(l) && isString(r) {
 			return boolType
 		}
+		if isTime(l) && isTime(r) {
+			return boolType
+		}
 
-	case "/", "-", "*":
+	case "-":
+		if isNumber(l) && isNumber(r) {
+			return combined(l, r)
+		}
+		if isTime(l) && isTime(r) {
+			return durationType
+		}
+
+	case "/", "*":
 		if isNumber(l) && isNumber(r) {
 			return combined(l, r)
 		}
@@ -255,6 +269,12 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 		if isString(l) && isString(r) {
 			return stringType
 		}
+		if isTime(l) && isDuration(r) {
+			return timeType
+		}
+		if isDuration(l) && isTime(r) {
+			return timeType
+		}
 
 	case "contains", "startsWith", "endsWith":
 		if isString(l) && isString(r) {
@@ -348,9 +368,9 @@ func (v *visitor) FunctionNode(node *ast.FunctionNode) reflect.Type {
 				fn.NumIn() == inputParamsCount &&
 				((fn.NumOut() == 1 && // Function with one return value
 					fn.Out(0).Kind() == reflect.Interface) ||
-				(fn.NumOut() == 2 && // Function with one return value and an error
-					fn.Out(0).Kind() == reflect.Interface &&
-					fn.Out(1) == errorType)) {
+					(fn.NumOut() == 2 && // Function with one return value and an error
+						fn.Out(0).Kind() == reflect.Interface &&
+						fn.Out(1) == errorType)) {
 				rest := fn.In(fn.NumIn() - 1) // function has only one param for functions and two for methods
 				if rest.Kind() == reflect.Slice && rest.Elem().Kind() == reflect.Interface {
 					node.Fast = true

checker/checker_test.go

@@ -176,6 +176,31 @@ func TestCheck(t *testing.T) {
 		"count(1..30, {# % 3 == 0}) > 0",
 		"map(1..3, {#}) == [1,2,3]",
 		"map(filter(ArrayOfFoo, {.Int64 > 0}), {.Bar})",
+		"Any == Time",
+		"Any != Time",
+		"Any > Time",
+		"Any >= Time",
+		"Any < Time",
+		"Any <= Time",
+		"Any - Time",
+		"Any == Any",
+		"Any != Any",
+		"Any > Any",
+		"Any >= Any",
+		"Any < Any",
+		"Any <= Any",
+		"Any - Any",
+		"Time == Any",
+		"Time != Any",
+		"Time > Any",
+		"Time >= Any",
+		"Time < Any",
+		"Time <= Any",
+		"Time - Any",
+		"Any + Duration",
+		"Duration + Any",
+		"Time + Duration",
+		"Duration + Time",
 	}
 	for _, test := range typeTests {
 		var err error
@@ -634,6 +659,8 @@ type mockEnv2 struct {
 	BoolFn     func() bool
 	NilFn      func()
 	Variadic   func(head string, xs ...int) int
+	Time       time.Time
+	Duration   time.Duration
 }
 
 func (p mockEnv2) Method(_ bar) int {

checker/types.go

@@ -2,6 +2,7 @@ package checker
 
 import (
 	"reflect"
+	"time"
 
 	"github.com/antonmedv/expr/ast"
 )
@@ -15,6 +16,8 @@ var (
 	arrayType     = reflect.TypeOf([]interface{}{})
 	mapType       = reflect.TypeOf(map[string]interface{}{})
 	interfaceType = reflect.TypeOf(new(interface{})).Elem()
+	timeType      = reflect.TypeOf(time.Time{})
+	durationType  = reflect.TypeOf(time.Duration(0))
 )
 
 func typeWeight(t reflect.Type) int {
@@ -125,6 +128,28 @@ func isNumber(t reflect.Type) bool {
 	return isInteger(t) || isFloat(t)
 }
 
+func isTime(t reflect.Type) bool {
+	t = dereference(t)
+	if t != nil {
+		switch t {
+		case timeType:
+			return true
+		}
+	}
+	return isInterface(t)
+}
+
+func isDuration(t reflect.Type) bool {
+	t = dereference(t)
+	if t != nil {
+		switch t {
+		case durationType:
+			return true
+		}
+	}
+	return false
+}
+
 func isBool(t reflect.Type) bool {
 	t = dereference(t)
 	if t != nil {

expr_test.go

@@ -474,6 +474,10 @@ func TestExpr_readme_example(t *testing.T) {
 
 func TestExpr(t *testing.T) {
 	date := time.Date(2017, time.October, 23, 18, 30, 0, 0, time.UTC)
+	tnow := time.Now()
+	oneDay, _ := time.ParseDuration("24h")
+	tnowPlusOne := tnow.Add(oneDay)
+
 	env := &mockEnv{
 		Any:     "any",
 		Int:     0,
@@ -494,12 +498,14 @@ func TestExpr(t *testing.T) {
 			{Origin: "MOW", Destination: "LED"},
 			{Origin: "LED", Destination: "MOW"},
 		},
-		BirthDay:      date,
-		Now:           time.Now(),
-		One:           1,
-		Two:           2,
-		Three:         3,
-		MultiDimArray: [][]int{{1, 2, 3}, {1, 2, 3}},
+		BirthDay:       date,
+		Now:            tnow,
+		NowPlusOne:     tnowPlusOne,
+		OneDayDuration: oneDay,
+		One:            1,
+		Two:            2,
+		Three:          3,
+		MultiDimArray:  [][]int{{1, 2, 3}, {1, 2, 3}},
 		Sum: func(list []int) int {
 			var ret int
 			for _, el := range list {
@@ -884,6 +890,50 @@ func TestExpr(t *testing.T) {
 			`Concat("a", 1, [])`,
 			`a1[]`,
 		},
+		{
+			`Tweets[0].Date < Now`,
+			true,
+		},
+		{
+			`Now > Tweets[0].Date`,
+			true,
+		},
+		{
+			`Now == Now`,
+			true,
+		},
+		{
+			`Now >= Now`,
+			true,
+		},
+		{
+			`Now <= Now`,
+			true,
+		},
+		{
+			`Now == NowPlusOne`,
+			false,
+		},
+		{
+			`Now != Now`,
+			false,
+		},
+		{
+			`Now != NowPlusOne`,
+			true,
+		},
+		{
+			`NowPlusOne - Now`,
+			oneDay,
+		},
+		{
+			`Now + OneDayDuration`,
+			tnowPlusOne,
+		},
+		{
+			`OneDayDuration + Now`,
+			tnowPlusOne,
+		},
 	}
 
 	for _, tt := range tests {
@@ -1339,9 +1389,7 @@ func TestIssue138(t *testing.T) {
 	require.Error(t, err)
 }
 
-//
 // Mock types
-//
 type mockEnv struct {
 	Any                  interface{}
 	Int, One, Two, Three int
@@ -1360,6 +1408,8 @@ type mockEnv struct {
 	Segments             []*segment
 	BirthDay             time.Time
 	Now                  time.Time
+	NowPlusOne           time.Time
+	OneDayDuration       time.Duration
 	Nil                  interface{}
 	NilStruct            *time.Time
 	NilInt               *int

file/source_test.go

@@ -48,8 +48,8 @@ func TestStringSource_SnippetSingleLine(t *testing.T) {
 		t.Errorf(unexpectedSnippet, t.Name(), str, "hello, world")
 	}
 	if str2, found := source.Snippet(2); found {
-		t.Error(snippetFound, t.Name(), 2)
+		t.Errorf(snippetFound, t.Name(), 2)
 	} else if str2 != "" {
-		t.Error(unexpectedSnippet, t.Name(), str2, "")
+		t.Errorf(unexpectedSnippet, t.Name(), str2, "")
 	}
 }