lmika/ucl
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Added separate Eval mode with option to isolate the environment

Browse source 
This allows for keeping variables isolated
This commit is contained in:
Leon Mika 2025-05-25 09:50:25 +10:00
parent 2e8e60f904
commit d8460f69bc
15 changed files with 176 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
repl/evaldisplay.go
View file

@ -14,7 +14,7 @@ import (
type NoResults struct{}
func (r *REPL) EvalAndDisplay(ctx context.Context, expr string) error {
res, err := r.inst.Eval(ctx, expr)
res, err := r.inst.EvalString(ctx, expr)
if err != nil {
if errors.Is(err, ucl.ErrNotConvertable) {
return nil

2
ucl/ast.go
View file

@ -172,6 +172,6 @@ var scanner = lexer.MustStateful(lexer.Rules{
var parser = participle.MustBuild[astScript](participle.Lexer(scanner),
participle.Elide("Whitespace", "Comment"))
func parse(r io.Reader) (*astScript, error) {
func parse(fname string, r io.Reader) (*astScript, error) {
return parser.Parse("test", r)
}

2
ucl/builtins/csv_test.go
View file

@ -45,7 +45,7 @@ func TestCSV_ReadRecord(t *testing.T) {
ucl.WithOut(&bfr),
)
_, err := inst.Eval(context.Background(), tt.eval)
_, err := inst.EvalString(context.Background(), tt.eval)
assert.NoError(t, err)
assert.Equal(t, tt.wantOut, bfr.String())
})

2
ucl/builtins/fs_test.go
View file

@ -29,7 +29,7 @@ func TestFS_Cat(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.FS(testFS)),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})

2
ucl/builtins/itrs_test.go
View file

@ -26,7 +26,7 @@ func TestItrs_ToList(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.Itrs()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {

2
ucl/builtins/lists_test.go
View file

@ -34,7 +34,7 @@ func TestLists_First(t *testing.T) {
ucl.WithModule(builtins.Itrs()),
ucl.WithModule(builtins.Lists()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {

2
ucl/builtins/log_test.go
View file

@ -34,7 +34,7 @@ func TestLog_Puts(t *testing.T) {
})),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {

2
ucl/builtins/os_test.go
View file

@ -28,7 +28,7 @@ func TestOS_Env(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.OS()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})

12
ucl/builtins/strs_test.go
View file

@ -28,7 +28,7 @@ func TestStrs_ToUpper(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.Strs()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -59,7 +59,7 @@ func TestStrs_ToLower(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.Strs()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -90,7 +90,7 @@ func TestStrs_Trim(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.Strs()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -122,7 +122,7 @@ func TestStrs_HasPrefix(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.Strs()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -160,7 +160,7 @@ func TestStrs_Split(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.Strs()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -191,7 +191,7 @@ func TestStrs_Join(t *testing.T) {
ucl.WithModule(builtins.Itrs()),
ucl.WithModule(builtins.Strs()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {

4
ucl/builtins/time_test.go
View file

@ -25,7 +25,7 @@ func TestTime_FromUnix(t *testing.T) {
inst := ucl.New(
ucl.WithModule(builtins.Time()),
)
res, err := inst.Eval(context.Background(), tt.eval)
res, err := inst.EvalString(context.Background(), tt.eval)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -47,7 +47,7 @@ func TestTime_Sleep(t *testing.T) {
ucl.WithModule(builtins.Time()),
)
_, err := inst.Eval(ctx, `time:sleep 1`)
_, err := inst.EvalString(ctx, `time:sleep 1`)
assert.Error(t, err)
assert.Equal(t, "context canceled", err.Error())
assert.True(t, time.Now().Sub(st) < time.Second)

3
ucl/env.go
View file

@ -61,6 +61,9 @@ func (ec *evalCtx) setOrDefineVar(name string, val Object) {
func (ec *evalCtx) getVar(name string) (Object, bool) {
if ec.vars == nil {
if ec.parent == nil {
return nil, false
}
return ec.parent.getVar(name)
}

42
ucl/inst.go
View file

@ -141,8 +141,25 @@ func (inst *Inst) Out() io.Writer {
return inst.out
}
func (inst *Inst) Eval(ctx context.Context, expr string) (any, error) {
res, err := inst.eval(ctx, expr)
type EvalOption func(*evalOptions)
func WithSubEnv() EvalOption {
return func(opts *evalOptions) {
opts.forkEnv = true
}
}
func (inst *Inst) Eval(ctx context.Context, r io.Reader, options ...EvalOption) (any, error) {
opts := evalOptions{
filename: "unnamed",
forkEnv: false,
}
for _, opt := range options {
opt(&opts)
}
res, err := inst.eval(ctx, r, opts)
if err != nil {
if errors.Is(err, ErrHalt) {
return nil, nil
@ -158,16 +175,29 @@ func (inst *Inst) Eval(ctx context.Context, expr string) (any, error) {
return goRes, nil
}
func (inst *Inst) eval(ctx context.Context, expr string) (Object, error) {
ast, err := parse(strings.NewReader(expr))
func (inst *Inst) EvalString(ctx context.Context, expr string) (any, error) {
return inst.Eval(ctx, strings.NewReader(expr))
}
type evalOptions struct {
filename string
forkEnv bool
}
func (inst *Inst) eval(ctx context.Context, r io.Reader, opts evalOptions) (Object, error) {
ast, err := parse(opts.filename, r)
if err != nil {
return nil, err
}
eval := evaluator{inst: inst}
// TODO: this should be a separate forkAndIsolate() session
return eval.evalScript(ctx, inst.rootEC, ast)
env := inst.rootEC
if opts.forkEnv {
env = env.fork()
}
return eval.evalScript(ctx, env, ast)
}
type PseudoVarHandler interface {

89
ucl/inst_test.go
View file

@ -3,6 +3,7 @@ package ucl_test
import (
"bytes"
"context"
"strings"
"ucl.lmika.dev/ucl"
"github.com/stretchr/testify/assert"
@ -113,7 +114,7 @@ func TestInst_Eval(t *testing.T) {
outW := bytes.NewBuffer(nil)
inst := ucl.New(ucl.WithOut(outW), ucl.WithTestBuiltin())
res, err := inst.Eval(ctx, tt.expr)
res, err := inst.EvalString(ctx, tt.expr)
if tt.wantErr != nil {
assert.ErrorIs(t, err, tt.wantErr)
@ -129,6 +130,90 @@ func TestInst_Eval(t *testing.T) {
}
}
func TestInst_Eval_WithSubEnv(t *testing.T) {
t.Run("global symbols should not leak across environments", func(t *testing.T) {
ctx := t.Context()
inst := ucl.New()
res, err := inst.Eval(ctx, strings.NewReader(`$a = "hello" ; $a`), ucl.WithSubEnv())
assert.NoError(t, err)
assert.Equal(t, "hello", res)
res, err = inst.Eval(ctx, strings.NewReader(`$a`), ucl.WithSubEnv())
assert.NoError(t, err)
assert.Nil(t, res)
})
t.Run("when using hooks, reading vars are not permitted to leak across environment", func(t *testing.T) {
ctx := t.Context()
hooks := make([]ucl.Invokable, 0)
inst := ucl.New()
inst.SetBuiltin("hook", func(ctx context.Context, args ucl.CallArgs) (any, error) {
var hookProc ucl.Invokable
if err := args.Bind(&hookProc); err != nil {
return nil, err
}
hooks = append(hooks, hookProc)
return nil, nil
})
res, err := inst.Eval(ctx, strings.NewReader(`$a = "hello" ; hook { $a }`), ucl.WithSubEnv())
assert.NoError(t, err)
assert.Nil(t, res)
res, err = inst.Eval(ctx, strings.NewReader(`$a = "world" ; hook { $a }`), ucl.WithSubEnv())
assert.NoError(t, err)
assert.Nil(t, res)
h1, err := hooks[0].Invoke(ctx, ucl.CallArgs{})
assert.NoError(t, err)
assert.Equal(t, "hello", h1)
h2, err := hooks[1].Invoke(ctx, ucl.CallArgs{})
assert.NoError(t, err)
assert.Equal(t, "world", h2)
})
t.Run("when using hooks, writing vars are not permitted to leak across environment", func(t *testing.T) {
ctx := t.Context()
hooks := make([]ucl.Invokable, 0)
inst := ucl.New()
inst.SetBuiltin("hook", func(ctx context.Context, args ucl.CallArgs) (any, error) {
var hookProc ucl.Invokable
if err := args.Bind(&hookProc); err != nil {
return nil, err
}
hooks = append(hooks, hookProc)
return nil, nil
})
res, err := inst.Eval(ctx, strings.NewReader(`$a = "hello" ; hook { $a = "new value" ; $a }`), ucl.WithSubEnv())
assert.NoError(t, err)
assert.Nil(t, res)
res, err = inst.Eval(ctx, strings.NewReader(`$a = "world" ; hook { $a }`), ucl.WithSubEnv())
assert.NoError(t, err)
assert.Nil(t, res)
h1, err := hooks[0].Invoke(ctx, ucl.CallArgs{})
assert.NoError(t, err)
assert.Equal(t, "new value", h1)
h2, err := hooks[1].Invoke(ctx, ucl.CallArgs{})
assert.NoError(t, err)
assert.Equal(t, "world", h2)
})
}
func TestInst_SetPseudoVar(t *testing.T) {
tests := []struct {
desc string
@ -155,7 +240,7 @@ func TestInst_SetPseudoVar(t *testing.T) {
inst.SetPseudoVar("bar", bar)
inst.SetMissingPseudoVarHandler(missingPseudoVarType{})
res, err := inst.Eval(t.Context(), tt.expr)
res, err := inst.EvalString(t.Context(), tt.expr)
if tt.wantErr {
assert.Error(t, err)

28
ucl/testbuiltins_test.go
View file

@ -151,7 +151,7 @@ func TestBuiltins_Echo(t *testing.T) {
outW := bytes.NewBuffer(nil)
inst := New(WithOut(outW), WithTestBuiltin())
res, err := inst.Eval(ctx, tt.expr)
res, err := inst.EvalString(ctx, tt.expr)
assert.NoError(t, err)
assert.Nil(t, res)
@ -1309,7 +1309,7 @@ func TestBuiltins_Keys(t *testing.T) {
}, nil
})
res, err := inst.Eval(ctx, tt.expr)
res, err := inst.EvalString(ctx, tt.expr)
assert.NoError(t, err)
assert.Len(t, res, len(tt.wantItems))
for _, i := range tt.wantItems {
@ -1349,7 +1349,7 @@ func TestBuiltins_Filter(t *testing.T) {
inst := New(WithOut(outW), WithTestBuiltin())
res, err := inst.Eval(ctx, tt.expr)
res, err := inst.EvalString(ctx, tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})
@ -1375,7 +1375,7 @@ func TestBuiltins_Reduce(t *testing.T) {
inst := New(WithOut(outW), WithTestBuiltin())
res, err := inst.Eval(ctx, tt.expr)
res, err := inst.EvalString(ctx, tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})
@ -1404,7 +1404,7 @@ func TestBuiltins_Head(t *testing.T) {
inst := New(WithOut(outW), WithTestBuiltin())
res, err := inst.Eval(ctx, tt.expr)
res, err := inst.EvalString(ctx, tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})
@ -1459,7 +1459,7 @@ func TestBuiltins_LtLeGtLe(t *testing.T) {
inst.SetVar("true", true)
inst.SetVar("false", false)
eqRes, err := inst.Eval(ctx, tt.expr)
eqRes, err := inst.EvalString(ctx, tt.expr)
if tt.wantErr {
assert.Error(t, err)
@ -1527,11 +1527,11 @@ func TestBuiltins_EqNe(t *testing.T) {
inst.SetVar("true", true)
inst.SetVar("false", false)
eqRes, err := inst.Eval(ctx, tt.expr)
eqRes, err := inst.EvalString(ctx, tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, eqRes)
neRes, err := inst.Eval(ctx, strings.ReplaceAll(tt.expr, "eq", "ne"))
neRes, err := inst.EvalString(ctx, strings.ReplaceAll(tt.expr, "eq", "ne"))
assert.NoError(t, err)
assert.Equal(t, !tt.want, neRes)
})
@ -1562,7 +1562,7 @@ func TestBuiltins_Str(t *testing.T) {
inst := New(WithOut(outW), WithTestBuiltin())
eqRes, err := inst.Eval(ctx, tt.expr)
eqRes, err := inst.EvalString(ctx, tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, eqRes)
})
@ -1598,7 +1598,7 @@ func TestBuiltins_Int(t *testing.T) {
inst := New(WithOut(outW), WithTestBuiltin())
eqRes, err := inst.Eval(ctx, tt.expr)
eqRes, err := inst.EvalString(ctx, tt.expr)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -1654,7 +1654,7 @@ func TestBuiltins_AddSubMupDivMod(t *testing.T) {
inst := New(WithOut(outW), WithTestBuiltin())
eqRes, err := inst.Eval(ctx, tt.expr)
eqRes, err := inst.EvalString(ctx, tt.expr)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -1705,7 +1705,7 @@ func TestBuiltins_AndOrNot(t *testing.T) {
inst.SetVar("true", true)
inst.SetVar("false", false)
eqRes, err := inst.Eval(ctx, tt.expr)
eqRes, err := inst.EvalString(ctx, tt.expr)
if tt.wantErr {
assert.Error(t, err)
} else {
@ -1742,7 +1742,7 @@ func TestBuiltins_Cat(t *testing.T) {
inst.SetVar("true", true)
inst.SetVar("false", false)
eqRes, err := inst.Eval(ctx, tt.expr)
eqRes, err := inst.EvalString(ctx, tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, eqRes)
})
@ -1750,7 +1750,7 @@ func TestBuiltins_Cat(t *testing.T) {
}
func evalAndDisplay(ctx context.Context, inst *Inst, expr string) error {
res, err := inst.eval(ctx, expr)
res, err := inst.eval(ctx, strings.NewReader(expr), evalOptions{})
if err != nil {
return err
}

40
ucl/userbuiltin_test.go
View file

@ -24,7 +24,7 @@ func TestInst_SetBuiltin(t *testing.T) {
return x + y, nil
})
res, err := inst.Eval(context.Background(), `add2 "Hello, " "World"`)
res, err := inst.EvalString(context.Background(), `add2 "Hello, " "World"`)
assert.NoError(t, err)
assert.Equal(t, "Hello, World", res)
})
@ -44,7 +44,7 @@ func TestInst_SetBuiltin(t *testing.T) {
return x + y, nil
})
res, err := inst.Eval(context.Background(), `add2 "Hello, " "World"`)
res, err := inst.EvalString(context.Background(), `add2 "Hello, " "World"`)
assert.NoError(t, err)
assert.Equal(t, "Hello, World", res)
})
@ -85,7 +85,7 @@ func TestInst_SetBuiltin(t *testing.T) {
for _, tt := range tests {
t.Run(tt.descr, func(t *testing.T) {
res, err := inst.Eval(context.Background(), tt.expr)
res, err := inst.EvalString(context.Background(), tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})
@ -108,7 +108,7 @@ func TestInst_SetBuiltin(t *testing.T) {
return pair{x, y}, nil
})
res, err := inst.Eval(context.Background(), `add2 "Hello" "World"`)
res, err := inst.EvalString(context.Background(), `add2 "Hello" "World"`)
assert.NoError(t, err)
assert.Equal(t, pair{"Hello", "World"}, res)
})
@ -149,7 +149,7 @@ func TestInst_SetBuiltin(t *testing.T) {
return x.x + ":" + x.y, nil
})
res, err := inst.Eval(context.Background(), tt.expr)
res, err := inst.EvalString(context.Background(), tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})
@ -176,7 +176,7 @@ func TestInst_SetBuiltin(t *testing.T) {
return []string{"1", "2", "3"}, nil
})
res, err := inst.Eval(context.Background(), tt.expr)
res, err := inst.EvalString(context.Background(), tt.expr)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
assert.Equal(t, tt.wantOut, outW.String())
@ -206,11 +206,11 @@ func TestCallArgs_Bind(t *testing.T) {
return ds.DoString(), nil
})
va, err := inst.Eval(ctx, `dostr (sa)`)
va, err := inst.EvalString(ctx, `dostr (sa)`)
assert.NoError(t, err)
assert.Equal(t, "do string A: a val", va)
vb, err := inst.Eval(ctx, `dostr (sb)`)
vb, err := inst.EvalString(ctx, `dostr (sb)`)
assert.NoError(t, err)
assert.Equal(t, "do string B: foo bar", vb)
})
@ -240,7 +240,7 @@ func TestCallArgs_Bind(t *testing.T) {
return fmt.Sprintf("[%v]", v), nil
})
res, err := inst.Eval(ctx, tt.eval)
res, err := inst.EvalString(ctx, tt.eval)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})
@ -295,7 +295,7 @@ func TestCallArgs_CanBind(t *testing.T) {
return nil, nil
})
_, err := inst.Eval(ctx, tt.eval)
_, err := inst.EvalString(ctx, tt.eval)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})
@ -332,7 +332,7 @@ func TestCallArgs_CanBind(t *testing.T) {
return h.Value(k), nil
})
res, err := inst.Eval(ctx, tt.eval)
res, err := inst.EvalString(ctx, tt.eval)
if tt.wantErr {
assert.Error(t, err)
assert.Nil(t, res)
@ -370,7 +370,7 @@ func TestCallArgs_CanBind(t *testing.T) {
ctx := context.Background()
res, err := inst.Eval(ctx, `wrap { |x| toUpper $x }`)
res, err := inst.EvalString(ctx, `wrap { |x| toUpper $x }`)
assert.NoError(t, err)
assert.Equal(t, "[[HELLO]]", res)
})
@ -401,7 +401,7 @@ func TestCallArgs_CanBind(t *testing.T) {
assert.NoError(t, err)
assert.Nil(t, before)
res, err := inst.Eval(ctx, `wrap { |x| toUpper $x }`)
res, err := inst.EvalString(ctx, `wrap { |x| toUpper $x }`)
assert.NoError(t, err)
assert.Nil(t, res)
@ -437,7 +437,7 @@ func TestCallArgs_MissingCommandHandler(t *testing.T) {
return fmt.Sprintf("was %v", name), nil
}))
res, err := inst.Eval(ctx, tt.eval)
res, err := inst.EvalString(ctx, tt.eval)
assert.NoError(t, err)
assert.Equal(t, tt.want, res)
})
@ -460,27 +460,27 @@ func TestCallArgs_IsTopLevel(t *testing.T) {
return nil, nil
})
_, err := inst.Eval(ctx, `lvl "one"`)
_, err := inst.EvalString(ctx, `lvl "one"`)
assert.NoError(t, err)
assert.True(t, res["one"])
_, err = inst.Eval(ctx, `echo (lvl "two")`)
_, err = inst.EvalString(ctx, `echo (lvl "two")`)
assert.NoError(t, err)
assert.True(t, res["two"])
_, err = inst.Eval(ctx, `proc doLvl { |n| lvl $n } ; doLvl "three"`)
_, err = inst.EvalString(ctx, `proc doLvl { |n| lvl $n } ; doLvl "three"`)
assert.NoError(t, err)
assert.False(t, res["three"])
_, err = inst.Eval(ctx, `doLvl "four"`)
_, err = inst.EvalString(ctx, `doLvl "four"`)
assert.NoError(t, err)
assert.False(t, res["four"])
_, err = inst.Eval(ctx, `["a"] | map { |x| doLvl "five" ; $x }`)
_, err = inst.EvalString(ctx, `["a"] | map { |x| doLvl "five" ; $x }`)
assert.NoError(t, err)
assert.False(t, res["five"])
_, err = inst.Eval(ctx, `if 1 { lvl "six" }`)
_, err = inst.EvalString(ctx, `if 1 { lvl "six" }`)
assert.NoError(t, err)
assert.True(t, res["six"])
})