Skip to content

Add includer explicitly to iface of datemath #49

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
ajroetker merged 1 commit into from
Jun 27, 2025
Merged

Add includer explicitly to iface of datemath #49

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 11 additions & 11 deletions vm/datemath.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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?
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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)
Expand All @@ -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
}
Expand Down
28 changes: 14 additions & 14 deletions vm/datemath_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)

Expand Down Expand Up @@ -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)

Expand All @@ -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)
/*
Expand All @@ -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)
}

Expand Down Expand Up @@ -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)

Expand Down