Examples with Val org.projectnessie.cel.common.types.ref.Val used on opensource projects

Example 1 with Val

use of org.projectnessie.cel.common.types.ref.Val in project cel-java by projectnessie.

the class CELTest method CustomInterpreterDecorator.

@Test
void CustomInterpreterDecorator() {
    AtomicReference<Interpretable> lastInstruction = new AtomicReference<>();
    InterpretableDecorator optimizeArith = i -> {
        lastInstruction.set(i);
        // Only optimize the instruction if it is a call.
        if (!(i instanceof InterpretableCall)) {
            return i;
        }
        InterpretableCall call = (InterpretableCall) i;
        // Only optimize the math functions when they have constant arguments.
        switch(call.function()) {
            case "_+_":
            case "_-_":
            case "_*_":
            case "_/_":
                // These are all binary operators so they should have to arguments
                Interpretable[] args = call.args();
                // an empty activation and the value returns as a constant.
                if (!(args[0] instanceof InterpretableConst) || !(args[1] instanceof InterpretableConst)) {
                    return i;
                }
                Val val = call.eval(emptyActivation());
                if (isError(val)) {
                    throw new RuntimeException(val.toString());
                }
                return newConstValue(call.id(), val);
            default:
                return i;
        }
    };
    Env env = newEnv(declarations(Decls.newVar("foo", Decls.Int)));
    AstIssuesTuple astIss = env.compile("foo == -1 + 2 * 3 / 3");
    env.program(astIss.getAst(), evalOptions(OptPartialEval), customDecorator(optimizeArith));
    assertThat(lastInstruction.get()).isInstanceOf(InterpretableCall.class);
    InterpretableCall call = (InterpretableCall) lastInstruction.get();
    Interpretable[] args = call.args();
    Interpretable lhs = args[0];
    assertThat(lhs).isInstanceOf(InterpretableAttribute.class);
    InterpretableAttribute lastAttr = (InterpretableAttribute) lhs;
    NamespacedAttribute absAttr = (NamespacedAttribute) lastAttr.attr();
    String[] varNames = absAttr.candidateVariableNames();
    assertThat(varNames).containsExactly("foo");
    Interpretable rhs = args[1];
    assertThat(rhs).isInstanceOf(InterpretableConst.class);
    InterpretableConst lastConst = (InterpretableConst) rhs;
    // This is the last number produced by the optimization.
    assertThat(lastConst.value()).isSameAs(IntOne);
}

Example 2 with Val

use of org.projectnessie.cel.common.types.ref.Val in project cel-java by projectnessie.

the class CELTest method GlobalVars.

@Test
void GlobalVars() {
    Type mapStrDyn = Decls.newMapType(Decls.String, Decls.Dyn);
    Env e = newEnv(declarations(Decls.newVar("attrs", mapStrDyn), Decls.newVar("default", Decls.Dyn), Decls.newFunction("get", Decls.newInstanceOverload("get_map", asList(mapStrDyn, Decls.String, Decls.Dyn), Decls.Dyn))));
    AstIssuesTuple astIss = e.compile("attrs.get(\"first\", attrs.get(\"second\", default))");
    // Create the program.
    ProgramOption funcs = functions(Overload.function("get", args -> {
        if (args.length != 3) {
            return newErr("invalid arguments to 'get'");
        }
        if (!(args[0] instanceof Mapper)) {
            return newErr("invalid operand of type '%s' to obj.get(key, def)", args[0].type());
        }
        Mapper attrs = (Mapper) args[0];
        if (!(args[1] instanceof StringT)) {
            return newErr("invalid key of type '%s' to obj.get(key, def)", args[1].type());
        }
        StringT key = (StringT) args[1];
        Val defVal = args[2];
        if (attrs.contains(key) == True) {
            return attrs.get(key);
        }
        return defVal;
    }));
    // Global variables can be configured as a ProgramOption and optionally overridden on Eval.
    Program prg = e.program(astIss.getAst(), funcs, globals(mapOf("default", "third")));
    // t.Run("global_default", func(t *testing.T) {
    Object vars = mapOf("attrs", mapOf());
    EvalResult out = prg.eval(vars);
    assertThat(out.getVal().equal(stringOf("third"))).isSameAs(True);
    // })
    // t.Run("attrs_alt", func(t *testing.T) {
    vars = mapOf("attrs", mapOf("second", "yep"));
    out = prg.eval(vars);
    assertThat(out.getVal().equal(stringOf("yep"))).isSameAs(True);
    // })
    // t.Run("local_default", func(t *testing.T) {
    vars = mapOf("attrs", mapOf(), "default", "fourth");
    out = prg.eval(vars);
    assertThat(out.getVal().equal(stringOf("fourth"))).isSameAs(True);
// })
}

Example 3 with Val

use of org.projectnessie.cel.common.types.ref.Val in project cel-java by projectnessie.

the class CELTest method EvalOptions.

@Test
void EvalOptions() {
    Env e = newEnv(declarations(Decls.newVar("k", Decls.String), Decls.newVar("v", Decls.Bool)));
    AstIssuesTuple astIss = e.compile("{k: true}[k] || v != false");
    Program prg = e.program(astIss.getAst(), evalOptions(OptExhaustiveEval));
    EvalResult outDetails = prg.eval(mapOf("k", "key", "v", true));
    assertThat(outDetails.getVal()).isSameAs(True);
    // Test to see whether 'v != false' was resolved to a value.
    // With short-circuiting it normally wouldn't be.
    EvalState s = outDetails.getEvalDetails().getState();
    Val lhsVal = s.value(astIss.getAst().getExpr().getCallExpr().getArgs(0).getId());
    assertThat(lhsVal).isSameAs(True);
    Val rhsVal = s.value(astIss.getAst().getExpr().getCallExpr().getArgs(1).getId());
    assertThat(rhsVal).isSameAs(True);
}

Example 4 with Val

use of org.projectnessie.cel.common.types.ref.Val in project cel-java by projectnessie.

the class ProtoTypeRegistry method newValue.

@Override
public Val newValue(String typeName, Map<String, Val> fields) {
    PbTypeDescription td = pbdb.describeType(typeName);
    if (td == null) {
        return unknownType(typeName);
    }
    Builder builder = td.newMessageBuilder();
    Val err = newValueSetFields(fields, td, builder);
    if (err != null) {
        return err;
    }
    Message msg = builder.build();
    return nativeToValue(msg);
}

Example 5 with Val

use of org.projectnessie.cel.common.types.ref.Val in project cel-java by projectnessie.

the class ProtoTypeRegistry method newValueSetFields.

private Val newValueSetFields(Map<String, Val> fields, PbTypeDescription td, Builder builder) {
    Map<String, FieldDescription> fieldMap = td.fieldMap();
    for (Entry<String, Val> nv : fields.entrySet()) {
        String name = nv.getKey();
        FieldDescription field = fieldMap.get(name);
        if (field == null) {
            return noSuchField(name);
        }
        // TODO resolve inefficiency for maps: first converted from a MapT to a native Java map and
        // then to a protobuf struct. The intermediate step (the Java map) could be omitted.
        Object value = nv.getValue().convertToNative(field.reflectType());
        if (value.getClass().isArray()) {
            value = Arrays.asList((Object[]) value);
        }
        FieldDescriptor pbDesc = field.descriptor();
        if (pbDesc.getJavaType() == JavaType.ENUM) {
            value = intToProtoEnumValues(field, value);
        }
        if (pbDesc.isMapField()) {
            value = toProtoMapStructure(pbDesc, value);
        }
        builder.setField(pbDesc, value);
    }
    return null;
}