func parseRequest(s []string) (ast.Value, bool, error) {
pairs := make([][2]*ast.Term, len(s))
nonGround := false
for i := range s {
var k *ast.Term
var v *ast.Term
var err error
if s[i][0] == ':' {
k = ast.NewTerm(ast.EmptyRef())
v, err = ast.ParseTerm(s[i][1:])
} else {
v, err = ast.ParseTerm(s[i])
if err == nil {
k = ast.NewTerm(ast.EmptyRef())
} else {
vs := strings.SplitN(s[i], ":", 2)
if len(vs) != 2 {
return nil, false, errRequestPathFormat
}
k, err = ast.ParseTerm(ast.RequestRootDocument.String() + "." + vs[0])
if err != nil {
return nil, false, errRequestPathFormat
}
v, err = ast.ParseTerm(vs[1])
}
}
if err != nil {
return nil, false, err
}
pairs[i] = [...]*ast.Term{k, v}
if !nonGround {
ast.WalkVars(v, func(x ast.Var) bool {
if x.Equal(ast.DefaultRootDocument.Value) {
return false
}
nonGround = true
return true
})
}
}
request, err := topdown.MakeRequest(pairs)
if err != nil {
return nil, false, err
}
return request, nonGround, nil
}
func (r *REPL) cmdUnset(args []string) error {
if len(args) != 1 {
return newBadArgsErr("unset <var>: expects exactly one argument")
}
term, err := ast.ParseTerm(args[0])
if err != nil {
return newBadArgsErr("argument must identify a rule")
}
v, ok := term.Value.(ast.Var)
if !ok {
return newBadArgsErr("argument must identify a rule")
}
mod := r.modules[r.currentModuleID]
rules := []*ast.Rule{}
for _, r := range mod.Rules {
if !r.Name.Equal(v) {
rules = append(rules, r)
}
}
if len(rules) == len(mod.Rules) {
fmt.Fprintln(r.output, "warning: no matching rules in current module")
return nil
}
cpy := mod.Copy()
cpy.Rules = rules
policies := r.store.ListPolicies(r.txn)
policies[r.currentModuleID] = cpy
for id, mod := range r.modules {
if id != r.currentModuleID {
policies[id] = mod
}
}
compiler := ast.NewCompiler()
if compiler.Compile(policies); compiler.Failed() {
return compiler.Errors
}
r.modules[r.currentModuleID] = cpy
return nil
}