func mangleEvent(ctx context.Context, store *storage.Storage, txn storage.Transaction, event *topdown.Event) error {
// Replace bindings with ref values with the values from storage.
cpy := event.Locals.Copy()
var err error
event.Locals.Iter(func(k, v ast.Value) bool {
if r, ok := v.(ast.Ref); ok {
var path storage.Path
path, err = storage.NewPathForRef(r)
if err != nil {
return true
}
var doc interface{}
doc, err = store.Read(ctx, txn, path)
if err != nil {
return true
}
v, err = ast.InterfaceToValue(doc)
if err != nil {
return true
}
cpy.Put(k, v)
}
return false
})
event.Locals = cpy
switch node := event.Node.(type) {
case *ast.Rule:
event.Node = topdown.PlugHead(node.Head(), event.Locals.Get)
case *ast.Expr:
event.Node = topdown.PlugExpr(node, event.Locals.Get)
}
return nil
}
func reduceMax(x interface{}) (ast.Value, error) {
switch x := x.(type) {
case []interface{}:
if len(x) == 0 {
return nil, empty{}
}
var max interface{}
for i := range x {
if util.Compare(max, x[i]) <= 0 {
max = x[i]
}
}
return ast.InterfaceToValue(max)
}
return nil, fmt.Errorf("max: source must be array")
}
// loadRequest returns the request defined in the REPL. The REPL loads the
// request from the data.repl.request document.
func (r *REPL) loadRequest(ctx context.Context, compiler *ast.Compiler) (ast.Value, error) {
params := topdown.NewQueryParams(ctx, compiler, r.store, r.txn, nil, ast.MustParseRef("data.repl.request"))
result, err := topdown.Query(params)
if err != nil {
return nil, err
}
if result.Undefined() {
return nil, nil
}
return ast.InterfaceToValue(result[0].Result)
}
