diff --git a/operator-context.go b/operator-context.go index fa3086c..35cda31 100644 --- a/operator-context.go +++ b/operator-context.go @@ -35,6 +35,8 @@ func evalContextValue(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error if dc, ok := childValue.(*dataCursor); ok { sourceCtx = dc.ctx } + } else { + return } if sourceCtx != nil { diff --git a/operator-filter.go b/operator-filter.go index 9854f9f..a9a6797 100644 --- a/operator-filter.go +++ b/operator-filter.go @@ -6,7 +6,6 @@ package expr import ( "fmt" - "io" "git.portale-stac.it/go-pkg/expr/kern" "git.portale-stac.it/go-pkg/expr/scan" @@ -25,9 +24,10 @@ func newFilterTerm(tk *scan.Token) (inst *scan.Term) { } func evalFilter(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) { - var leftValue, rightValue any + // var leftValue, rightValue any + var leftValue any var it kern.Iterator - var item any + // var item any var ok bool if err = opTerm.CheckOperands(); err != nil { @@ -44,31 +44,120 @@ func evalFilter(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) { } } - values := kern.NewListA() - for item, err = it.Next(); err == nil; item, err = it.Next() { - ctx.SetVar("_", item) + // values := kern.NewListA() + // for item, err = it.Next(); err == nil; item, err = it.Next() { + // ctx.SetVar("_", item) + // ctx.SetVar("__", it.Index()) + // ctx.SetVar("_#", it.Count()) + // if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil { + // if success, valid := kern.ToBool(rightValue); valid { + // if success { + // values.AppendItem(item) + // } + // } else { + // err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", rightValue, rightValue) + // } + // } + // ctx.DeleteVar("_#") + // ctx.DeleteVar("__") + // ctx.DeleteVar("_") + // if err != nil { + // break + // } + // } + // if err == io.EOF { + // err = nil + // } + // v = values + + v = newFilerIterator(ctx, it, opTerm.Children[1]) + return +} + +const filterIteratorType = "filter" + +type filterIterator struct { + kern.IteratorBase + ctx kern.ExprContext + itSrc kern.Iterator + expr *scan.Term +} + +func newFilerIterator(ctx kern.ExprContext, itSrc kern.Iterator, filterExpr *scan.Term) (it *filterIterator) { + it = &filterIterator{ + IteratorBase: kern.IteratorBase{}, + ctx: ctx, + itSrc: itSrc, + expr: filterExpr, + } + it.IteratorBase.Reset() + return +} + +func (it *filterIterator) TypeName() string { + return filterIteratorType +} + +func (it *filterIterator) String() string { + return fmt.Sprintf("$(%s %s bool-expr)", it.itSrc, filterIteratorType) +} + +func (it *filterIterator) Next() (item any, err error) { + var attempt, result any + + ctx := it.ctx + + for attempt, err = it.itSrc.Next(); err == nil; attempt, err = it.itSrc.Next() { + ctx.SetVar("_", attempt) ctx.SetVar("__", it.Index()) ctx.SetVar("_#", it.Count()) - if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil { - if success, valid := kern.ToBool(rightValue); valid { - if success { - values.AppendItem(item) - } - } else { - err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", rightValue, rightValue) - } - } + result, err = it.expr.Compute(ctx) ctx.DeleteVar("_#") ctx.DeleteVar("__") ctx.DeleteVar("_") + + if err == nil { + if success, valid := kern.ToBool(result); valid { + if success { + item = attempt + break + } + } else { + err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", result, result) + } + } if err != nil { break } } - if err == io.EOF { - err = nil + + it.SetCurrent(item) + return +} + +// func (it *filterIterator) Reset() (err error) { +// err = it.itLeft.Reset() +// it.IteratorBase.Reset() +// return +// } + +func (it *filterIterator) CallOperation(name string, args map[string]any) (v any, err error) { + switch name { + case kern.NextName: + v, err = it.Next() + // case kern.ResetName: + // err = it.Reset() + // case kern.CleanName: + // err = it.Clean() + case kern.IndexName: + v = it.Index() + case kern.CurrentName: + v, err = it.Current() + case kern.CountName: + v = it.Count() + default: + err = kern.ErrNoOperation(name) } - v = values return } diff --git a/operator-map.go b/operator-map.go index 1175f68..40ed54b 100644 --- a/operator-map.go +++ b/operator-map.go @@ -6,7 +6,6 @@ package expr import ( "fmt" - "io" "git.portale-stac.it/go-pkg/expr/kern" "git.portale-stac.it/go-pkg/expr/scan" @@ -25,9 +24,10 @@ func newMapTerm(tk *scan.Token) (inst *scan.Term) { } func evalMap(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) { - var leftValue, rightValue any + // var leftValue, rightValue any + var leftValue any var it kern.Iterator - var item any + // var item any var ok bool if err = opTerm.CheckOperands(); err != nil { @@ -44,27 +44,28 @@ func evalMap(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) { } } - values := kern.NewListA() - for item, err = it.Next(); err == nil; item, err = it.Next() { - ctx.SetVar("_", item) - ctx.SetVar("__", it.Index()) - ctx.SetVar("_#", it.Count()) - if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil { - values.AppendItem(rightValue) - } - ctx.DeleteVar("_#") - ctx.DeleteVar("__") - ctx.DeleteVar("_") - if err != nil { - break - } - } - if err == io.EOF { - err = nil - } - if err == nil { - v = values - } + // values := kern.NewListA() + // for item, err = it.Next(); err == nil; item, err = it.Next() { + // ctx.SetVar("_", item) + // ctx.SetVar("__", it.Index()) + // ctx.SetVar("_#", it.Count()) + // if rightValue, err = opTerm.Children[1].Compute(ctx); err == nil { + // values.AppendItem(rightValue) + // } + // ctx.DeleteVar("_#") + // ctx.DeleteVar("__") + // ctx.DeleteVar("_") + // if err != nil { + // break + // } + // } + // if err == io.EOF { + // err = nil + // } + // if err == nil { + // v = values + // } + v, err = NewIterIter(it, ctx, opTerm.Children[1:]) return } diff --git a/t_funcs_test.go b/t_funcs_test.go index 1b9afed..f4b711f 100644 --- a/t_funcs_test.go +++ b/t_funcs_test.go @@ -54,8 +54,7 @@ func TestFuncs2(t *testing.T) { inputs := []inputType{ /* 1 */ {`sum=func(a,b){a+b}; sum(1,2)`, int64(3), nil}, /* 2 */ {`sum=func(a,b){a+b}; sum(1)`, nil, `sum(): too few params -- expected 2, got 1`}, - /* 3 */ {`["1", "2", "3"] map int()`, nil, `int(): too few params -- expected 1, got 0`}, - /* 4 */ {`builtin "iterator"; times=func(a,b){a*b}; run($(["1", "2", "3"]), times)`, nil, `operator(): missing params -- a, b`}, + /* 3 */ {`builtin "iterator"; times=func(a,b){a*b}; run($(["1", "2", "3"]), times)`, nil, `operator(): missing params -- a, b`}, } // runTestSuiteSpec(t, section, inputs, 4) runTestSuite(t, section, inputs) diff --git a/t_iterator_test.go b/t_iterator_test.go index 660bb85..af2bede 100644 --- a/t_iterator_test.go +++ b/t_iterator_test.go @@ -35,26 +35,60 @@ func TestIteratorParser(t *testing.T) { /* 20 */ {`it=$({1:"one",2:"two",3:"three"}, "default", "value"); it++`, "one", nil}, /* 21 */ {`it=$({1:"one",2:"two",3:"three"}, "desc", "key"); it++`, int64(3), nil}, /* 22 */ {`it=$({1:"one",2:"two",3:"three"}, "asc", "item"); it++`, kern.NewList([]any{int64(1), "one"}), nil}, - /* 23 */ {`builtin "os.file"; fileLineIterator("test-file.txt") map ${__}`, kern.NewList([]any{int64(0), int64(1)}), nil}, - /* 24 */ {`builtin "os.file"; #(fileLineIterator("test-file.txt") filter (#${_} == 2))`, int64(0), nil}, - /* 25 */ {`builtin "os.file"; #(fileLineIterator("test-file.txt") filter (#${_} == 3))`, int64(2), nil}, - /* 26 */ {`#($(10) map ${_})`, int64(10), nil}, - /* 27 */ {`#($(10,0) map ${_})`, int64(10), nil}, - /* 28 */ {`$(10) digest ${_}`, int64(9), nil}, - /* 29 */ {`$(10,0) digest ${_}`, int64(1), nil}, - /* 30 */ {`$(10,0,-2) digest ${_}`, int64(2), nil}, - /* 31 */ {`[3,4,5] map ${_#}`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil}, } // runTestSuiteSpec(t, section, inputs, 10) runTestSuite(t, section, inputs) } -func TestCatIterator(t *testing.T) { - section := "Iterator" +func TestFilterIterator(t *testing.T) { + section := "Iterator-Filter" inputs := []inputType{ - /* 1 */ {`([1] cat [2]) map $_`, kern.NewList([]any{int64(1), int64(2)}), nil}, + /* 1 */ {`$$([1,2,3] filter $_%2==0)`, kern.NewList([]any{int64(2)}), nil}, + /* 2 */ {`it = [1,2,3] filter $_%2!=1; $$(it)`, kern.NewList([]any{int64(2)}), nil}, + /* 3 */ {`builtin "os.file"; #$$(fileLineIterator("test-file.txt") filter (#${_} == 2))`, int64(0), nil}, + /* 4 */ {`builtin "os.file"; #$$(fileLineIterator("test-file.txt") filter (#${_} == 3))`, int64(2), nil}, + } + + // runTestSuiteSpec(t, section, inputs, 2) + runTestSuite(t, section, inputs) +} + +func TestDigestIterator(t *testing.T) { + section := "Iterator-Digest" + inputs := []inputType{ + /* 1 */ {`$(10) digest ${_}`, int64(9), nil}, + /* 2 */ {`$(10,0) digest ${_}`, int64(1), nil}, + /* 3 */ {`$(10,0,-2) digest ${_}`, int64(2), nil}, + } + + // runTestSuiteSpec(t, section, inputs, 2) + runTestSuite(t, section, inputs) +} + +func TestCatIterator(t *testing.T) { + section := "Iterator-Cat" + inputs := []inputType{ + /* 1 */ {`$$([1] cat [])`, kern.NewList([]any{int64(1)}), nil}, /* 2 */ {`$$([1] cat [2])`, kern.NewList([]any{int64(1), int64(2)}), nil}, + /* 3 */ {`$$([1] cat nil)`, kern.NewList([]any{int64(1)}), nil}, + /* 4 */ {`$$(nil cat [2])`, kern.NewList([]any{int64(2)}), nil}, + /* 5 */ {`$$(nil cat nil)`, kern.NewList([]any{}), nil}, + /* 6 */ {`$$(["a","b"] cat ["x"-true])`, nil, `[1:23] left operand 'x' [string] and right operand 'true' [bool] are not compatible with operator "-"`}, + } + + // runTestSuiteSpec(t, section, inputs, 6) + runTestSuite(t, section, inputs) +} + +func TestMapIterator(t *testing.T) { + section := "Iterator-Map" + inputs := []inputType{ + /* 1 */ {`$$([3,4,5] map ${_#})`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil}, + /* 2 */ {`#$$($(10) map ${_})`, int64(10), nil}, + /* 3 */ {`#$$($(10,0) map ${_})`, int64(10), nil}, + /* 4 */ {`builtin "os.file"; $$(fileLineIterator("test-file.txt") map ${__})`, kern.NewList([]any{int64(0), int64(1)}), nil}, + /* 5 */ {`$$(["1", "2", "3"] map int())`, nil, `int(): too few params -- expected 1, got 0`}, } // runTestSuiteSpec(t, section, inputs, 2) diff --git a/t_operator_test.go b/t_operator_test.go index e83bb4c..1d169fd 100644 --- a/t_operator_test.go +++ b/t_operator_test.go @@ -43,49 +43,16 @@ func TestOperator(t *testing.T) { runTestSuite(t, section, inputs) } -func TestOperatorMap(t *testing.T) { - section := "Operator-Map" - inputs := []inputType{ - /* 1 */ {`a=1; --a`, int64(0), nil}, - /* 2 */ {`[1,2,3] map var("_")`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil}, - /* 3 */ {`[1,2,3] map $_`, kern.NewList([]any{int64(1), int64(2), int64(3)}), nil}, - } - - // runTestSuiteSpec(t, section, inputs, 3) - runTestSuite(t, section, inputs) -} - -func TestOperatorFilter(t *testing.T) { - section := "Operator-Filter" - inputs := []inputType{ - /* 1 */ {`[1,2,3,4] filter ($_ % 2 == 0)`, kern.NewList([]any{int64(2), int64(4)}), nil}, - } - - // runTestSuiteSpec(t, section, inputs, 1) - runTestSuite(t, section, inputs) -} - func TestOperatorDigest(t *testing.T) { section := "Operator-Digest" inputs := []inputType{ - /* 1 */ {`max=0; [2,3,1] digest max=(($_ > max) ? {$_} :: {max})`, int64(3), nil}, + /* 1 */ {`max=0; [2,3,1] digest (max=(($_ > max) ? {$_} :: {max}))`, int64(3), nil}, } // runTestSuiteSpec(t, section, inputs, 29) runTestSuite(t, section, inputs) } -func TestOperatorCat(t *testing.T) { - section := "Operator-Cat" - inputs := []inputType{ - /* 1 */ {`["a","b"] cat ["x"]`, kern.NewList([]any{"a", "b", "x"}), nil}, - /* 2 */ {`["a","b"] cat ["x"-true]`, nil, `[1:20] left operand 'x' [string] and right operand 'true' [bool] are not compatible with operator "-"`}, - } - - // runTestSuiteSpec(t, section, inputs, 2) - runTestSuite(t, section, inputs) -} - func TestOperatorGroupBy(t *testing.T) { section := "Operator-GroupBy" inputs := []inputType{