Add includer explicitly to iface of datemath (#49)

Co-authored-by: AJ Roetker <[email protected]>

Author: ajroetker

vm/datemath.go

@@ -26,37 +26,37 @@ type DateConverter struct {
 	err         error
 }
 
-func FindBoundary(anchorTime time.Time, ctx expr.EvalIncludeContext, fns BoundaryFns) (time.Time, error) {
+func FindBoundary(anchorTime time.Time, ctx expr.EvalContext, includer expr.Includer, fns BoundaryFns) (time.Time, error) {
 	dc := &DateConverter{
 		at: anchorTime,
 	}
 	for _, fn := range fns {
-		fn(dc, ctx)
+		fn(dc, ctx, includer)
 	}
 	return dc.bt, dc.err
 }
 
-type BoundaryFns []func(*DateConverter, expr.EvalIncludeContext)
+type BoundaryFns []func(*DateConverter, expr.EvalContext, expr.Includer)
 
 func CalcBoundaryFns(n expr.Node) BoundaryFns {
 	return findDateMathFn(n)
 }
 
-func NewDateConverterWithAnchorTime(ctx expr.EvalIncludeContext, n expr.Node, at time.Time) (*DateConverter, error) {
+func NewDateConverterWithAnchorTime(ctx expr.EvalContext, includer expr.Includer, n expr.Node, at time.Time) (*DateConverter, error) {
 	dc := &DateConverter{
 		at: at,
 	}
 	fns := findDateMathFn(n)
-	dc.bt, dc.err = FindBoundary(dc.at, ctx, fns)
+	dc.bt, dc.err = FindBoundary(dc.at, ctx, includer, fns)
 	if dc.err == nil && len(fns) > 0 {
 		dc.HasDateMath = true
 	}
 	return dc, dc.err
 }
 
 // NewDateConverter takes a node expression
-func NewDateConverter(ctx expr.EvalIncludeContext, n expr.Node) (*DateConverter, error) {
-	return NewDateConverterWithAnchorTime(ctx, n, time.Now())
+func NewDateConverter(ctx expr.EvalContext, inc expr.Includer, n expr.Node) (*DateConverter, error) {
+	return NewDateConverterWithAnchorTime(ctx, inc, n, time.Now())
 }
 func compareBoundaries(currBoundary, newBoundary time.Time) time.Time {
 	// Should we check for is zero on the newBoundary?
@@ -136,7 +136,7 @@ func findDateMathFn(node expr.Node) BoundaryFns {
 
 				if nowRegex.MatchString(val) {
 					argIdx := i
-					fns = append(fns, func(d *DateConverter, ctx expr.EvalIncludeContext) {
+					fns = append(fns, func(d *DateConverter, ctx expr.EvalContext, inc expr.Includer) {
 						// If left side is datemath   "now-3d" < ident then re-write to have ident on left
 						var lhv value.Value
 						op := n.Operator.T
@@ -249,7 +249,7 @@ func findDateMathFn(node expr.Node) BoundaryFns {
 //	- Expression is true
 //	- Will become false when Ct passes lower bound (exit event)
 //	- Returns re-evaluation time when this will be exit the window
-func findBoundaryForBetween(n *expr.TriNode) func(d *DateConverter, ctx expr.EvalIncludeContext) {
+func findBoundaryForBetween(n *expr.TriNode) func(d *DateConverter, ctx expr.EvalContext, inc expr.Includer) {
 
 	// Check if first arg is IdentityNode and other two are StringNodes
 	_, isFirstIdentity := n.Args[0].(*expr.IdentityNode)
@@ -268,9 +268,9 @@ func findBoundaryForBetween(n *expr.TriNode) func(d *DateConverter, ctx expr.Eva
 		return nil
 	}
 
-	return func(d *DateConverter, ctx expr.EvalIncludeContext) {
+	return func(d *DateConverter, ctx expr.EvalContext, inc expr.Includer) {
 
-		lhv, ok := Eval(ctx, arg1)
+		lhv, ok := EvalInc(inc, ctx, arg1)
 		if !ok {
 			return
 		}

vm/datemath_test.go

@@ -132,12 +132,12 @@ func TestDateBoundaries(t *testing.T) {
 		fs := rel.MustParseFilter(tc.filter)
 
 		// Converter to find/calculate date operations
-		dc, err := vm.NewDateConverter(includeCtx, fs.Filter)
+		dc, err := vm.NewDateConverter(includeCtx, includeCtx, fs.Filter)
 		require.Equal(t, nil, err)
 		require.True(t, dc.HasDateMath)
 
 		// initially we should not match
-		matched, evalOk := vm.Matches(includeCtx, fs)
+		matched, evalOk := vm.MatchesInc(includeCtx, includeCtx, fs)
 		assert.True(t, evalOk, tc.filter)
 		assert.Equal(t, tc.match, matched)
 
@@ -191,7 +191,7 @@ func TestDateMath(t *testing.T) {
 		fs := rel.MustParseFilter(tc.filter)
 
 		// Converter to find/calculate date operations
-		dc, err := vm.NewDateConverter(evalCtx, fs.Filter)
+		dc, err := vm.NewDateConverter(evalCtx, evalCtx, fs.Filter)
 		require.NoError(t, err)
 		require.True(t, dc.HasDateMath, tc.filter)
 
@@ -200,12 +200,12 @@ func TestDateMath(t *testing.T) {
 		assert.Equal(t, nil, err)
 
 		// Converter to find/calculate date operations
-		dc, err = vm.NewDateConverter(evalCtx, node)
+		dc, err = vm.NewDateConverter(evalCtx, evalCtx, node)
 		assert.Equal(t, nil, err)
 		assert.True(t, dc.HasDateMath)
 
 		// initially we should not match
-		matched, evalOk := vm.Matches(evalCtx, fs)
+		matched, evalOk := vm.MatchesInc(evalCtx, evalCtx, fs)
 		assert.True(t, evalOk)
 		assert.Equal(t, false, matched)
 		/*
@@ -225,32 +225,32 @@ func TestDateMath(t *testing.T) {
 	}
 
 	fs := rel.MustParseFilter(`FILTER AND (INCLUDE not_valid_lookup)`)
-	_, err := vm.NewDateConverter(evalCtx, fs.Filter)
+	_, err := vm.NewDateConverter(evalCtx, evalCtx, fs.Filter)
 	// We assume that the inclusions are preresolved
 	assert.Nil(t, err)
 
 	fs = rel.MustParseFilter(`FILTER AND ( last_event > "now-3x")`)
-	_, err = vm.NewDateConverter(evalCtx, fs.Filter)
+	_, err = vm.NewDateConverter(evalCtx, evalCtx, fs.Filter)
 	assert.NotNil(t, err)
 
 	fs = rel.MustParseFilter(`FILTER AND ( last_event == "now-")`)
-	_, err = vm.NewDateConverter(evalCtx, fs.Filter)
+	_, err = vm.NewDateConverter(evalCtx, evalCtx, fs.Filter)
 	assert.NotEqual(t, nil, err)
 
 	fs = rel.MustParseFilter(`FILTER AND ( last_event == "now+")`)
-	_, err = vm.NewDateConverter(evalCtx, fs.Filter)
+	_, err = vm.NewDateConverter(evalCtx, evalCtx, fs.Filter)
 	assert.NotEqual(t, nil, err)
 
 	fs = rel.MustParseFilter(`FILTER AND ( last_event == "now+now")`)
-	_, err = vm.NewDateConverter(evalCtx, fs.Filter)
+	_, err = vm.NewDateConverter(evalCtx, evalCtx, fs.Filter)
 	assert.NotEqual(t, nil, err)
 
 	fs = rel.MustParseFilter(`FILTER AND ( last_event == "now-3d")`)
-	_, err = vm.NewDateConverter(evalCtx, fs.Filter)
+	_, err = vm.NewDateConverter(evalCtx, evalCtx, fs.Filter)
 	assert.Equal(t, nil, err)
 
 	fs = rel.MustParseFilter(`FILTER AND ( last_event == "now")`)
-	_, err = vm.NewDateConverter(evalCtx, fs.Filter)
+	_, err = vm.NewDateConverter(evalCtx, evalCtx, fs.Filter)
 	assert.Equal(t, nil, err)
 }
 
@@ -351,11 +351,11 @@ func TestDateBoundaryForBetween(t *testing.T) {
 
 			fs := rel.MustParseFilter(tc.filter)
 
-			dc, err := vm.NewDateConverterWithAnchorTime(includeCtx, fs.Filter, today)
+			dc, err := vm.NewDateConverterWithAnchorTime(includeCtx, includeCtx, fs.Filter, today)
 			require.NoError(t, err)
 			require.True(t, dc.HasDateMath)
 
-			matched, evalOk := vm.Matches(includeCtx, fs)
+			matched, evalOk := vm.MatchesInc(includeCtx, includeCtx, fs)
 			assert.True(t, evalOk)
 			assert.Equal(t, tc.match, matched)