Refine search
ParserContext context = new ParserContext(); context.addImport("MVEL", MVEL.class); context.addImport("MvelHelper", MvelHelper.class); context.addImport("CollectionUtils", SelectizeCollectionUtils.class); if (MapUtils.isNotEmpty(additionalContextImports)) { for (Entry<String, Class<?>> entry : additionalContextImports.entrySet()) { context.addImport(entry.getKey(), entry.getValue()); exp = MVEL.compileExpression(modifiedRule, context); expressionCache.put(rule, exp); Object test = MVEL.executeExpression(exp, mvelParameters); if (test == null) {
public Object eval(String str, Map vars) { ParserContext context = new ParserContext(); context.addPackageImport("org.jbpm.task"); context.addPackageImport("org.jbpm.task.service"); context.addPackageImport("org.jbpm.task.query"); context.addPackageImport("java.util"); vars.put("now", new Date()); return MVELSafeHelper.getEvaluator().executeExpression(MVEL.compileExpression(str, context), vars); }
/** * Having a parser context that imports the classes speeds MVEL by up to 60%. */ protected ParserContext getParserContext() { if (parserContext == null) { parserContext = new ParserContext(); parserContext.addImport("MVEL", MVEL.class); parserContext.addImport("MvelHelper", MvelHelper.class); } return parserContext; }
@Override public Object compile(String expression, Map<String, Object> parameters) { logger.debug("About to compile mvel expression {}", expression); ClassLoader classLoader = (ClassLoader) parameters.get("classloader"); if (classLoader == null) { classLoader = this.getClass().getClassLoader(); } ParserConfiguration config = new ParserConfiguration(); config.setClassLoader(classLoader); ParserContext context = new ParserContext(config); if (parameters != null) { @SuppressWarnings("unchecked") Set<String> imports = (Set<String>)parameters.get("imports"); if (imports != null) { for(String clazz : imports) { try { Class<?> cl = Class.forName(clazz, true, classLoader); context.addImport(cl.getSimpleName(), cl); } catch (ClassNotFoundException e) { logger.warn("Unable to load class {} due to {}", clazz, e.getException()); }; } } } return MVEL.compileExpression(expression, context); }
public static Object eval(String str, Map vars) { ExpressionCompiler compiler = new ExpressionCompiler(str.trim()); ParserContext context = new ParserContext(); context.addPackageImport("org.jbpm.task"); context.addPackageImport("org.jbpm.task.service"); context.addPackageImport("org.jbpm.task.query"); context.addPackageImport("java.util"); vars.put("now", new Date()); return MVEL.executeExpression(compiler.compile(context), vars); }
public void testParameterizedTypeInStrictMode() { ParserContext ctx = new ParserContext(); ctx.setStrongTyping(true); ctx.addInput("foo", HashMap.class, new Class[]{String.class, String.class}); ExpressionCompiler compiler = new ExpressionCompiler("foo.get('bar').toUpperCase()", ctx); compiler.compile(); }
public void testWithMultipleMethodCalls() { ParserContext ctx = ParserContext.create().stronglyTyped().withInput("foo", Foo.class); MVEL.compileExpression("with (foo) { setName('foo'), setBar(null) }", ctx); }
public void testAssignmentOnTwoDimensionalArrayUsingIndexedInput() { ParserConfiguration conf = new ParserConfiguration(); ParserContext pctx = new ParserContext( conf ); pctx.setIndexAllocation( true ); pctx.setStrictTypeEnforcement(true); pctx.setStrongTyping(true); pctx.addInput("array", Double[][].class); pctx.addIndexedInput("array"); Map vars = new HashMap() {{ put("array", new Double[2][2]); }}; assertEquals(42.0, MVEL.executeExpression(MVEL.compileExpression("array[1][1] = 42.0;\narray[1][1]", pctx), vars)); } }
public void testJIRA161() { Serializable s = MVEL.compileExpression("1==-(-1)", ParserContext.create().stronglyTyped()); assertEquals(1 == -(-1), MVEL.executeExpression(s)); ParserContext ctx = new ParserContext(); ctx.setStrongTyping(true); CompiledExpression compiledExpression = new ExpressionCompiler("1==-(-1)", ctx).compile(); assertEquals(1 == -(-1), MVEL.executeExpression(compiledExpression)); }
public static Object eval(String str, Map<String, Object> vars) { ParserConfiguration pconf = new ParserConfiguration(); pconf.addPackageImport("org.kie.internal.task.api.model"); pconf.addPackageImport("org.jbpm.services.task"); pconf.addPackageImport("org.jbpm.services.task.impl.model"); pconf.addPackageImport("org.jbpm.services.task.query"); pconf.addPackageImport("org.jbpm.services.task.internals.lifecycle"); pconf.addImport(Status.class); pconf.addImport(Allowed.class); pconf.addPackageImport("java.util"); ParserContext context = new ParserContext(pconf); Serializable s = MVEL.compileExpression(str.trim(), context); if (vars != null) { return MVELSafeHelper.getEvaluator().executeExpression(s, vars); } else { return MVELSafeHelper.getEvaluator().executeExpression(s); } }
public void testMVEL187() { ParserContext context = new ParserContext(); context.addPackageImport("test"); context.addInput("outer", Outer.class); Object compiled = MVEL.compileExpression( "outer.getInner().getValue()", context); Map<String, Object> vars = new HashMap<String, Object>(); vars.put("outer", new Outer()); VariableResolverFactory varsResolver = new MapVariableResolverFactory(vars); assertEquals(2, executeExpression(compiled, varsResolver)); }
public static void exerciseWorkaround() { System.setProperty("mvel2.disable.jit", "true"); String rule = "CollectionUtils.intersection(level1.level2.getMultiValueSkuAttributes()[\"TEST-VALID\"],[\"TEST-VALID\"]).size()>0"; ParserContext context = new ParserContext(); context.addImport("CollectionUtils", SelectizeCollectionUtils.class); Serializable exp = MVEL.compileExpression(rule, context); executeTestCase(exp, "TEST-INVALID"); boolean response = executeTestCase(exp, "TEST-VALID"); if (!response) { //With the workaround, we should never get here System.out.print("false"); } else { //The expression should never be corrupted now that we've removed the overloaded method (this is the workaround) System.out.print("true"); } }
public void testGetCorrectInputs() { String str = "total = total + $cheese.price"; ParserConfiguration pconf = new ParserConfiguration(); ParserContext pctx = new ParserContext(pconf); pctx.setStrongTyping(true); pctx.addInput("total", int.class); pctx.addInput("$cheese", Cheese.class); ExecutableStatement stmt = (ExecutableStatement) MVEL.compileExpression(str, pctx); assertTrue("Should not contain" + pctx.getVariables(), pctx.getVariables().isEmpty()); }
@Override public Object getInstance(ObjectModel model, ClassLoader cl, Map<String, Object> contextParams) { Object instance = null; InternalRuntimeManager manager = null; if (contextParams.containsKey("runtimeManager")) { manager = (InternalRuntimeManager) contextParams.get("runtimeManager"); instance = manager.getCacheManager().get(model.getIdentifier()); if (instance != null) { return instance; } } ParserConfiguration config = new ParserConfiguration(); config.setClassLoader(cl); ParserContext ctx = new ParserContext(config); if (contextParams != null) { for (Map.Entry<String, Object> entry : contextParams.entrySet()) { ctx.addVariable(entry.getKey(), entry.getValue().getClass()); } } Object compiledExpression = MVEL.compileExpression(model.getIdentifier(), ctx); instance = MVELSafeHelper.getEvaluator().executeExpression( compiledExpression, contextParams ); if (manager != null && instance instanceof Cacheable) { manager.getCacheManager().add(model.getIdentifier(), instance); } return instance; }
public void testConcatWithLineBreaks() { ParserContext ctx = new ParserContext(); ctx.setDebugSymbols(true); ctx.setSourceFile("source.mv"); ExpressionCompiler parser = new ExpressionCompiler("\"foo\"+\n\"bar\"", ctx); assertEquals("foobar", executeExpression(parser.compile())); }
public void testDetermineRequiredInputsInConstructor() throws Exception { ParserContext ctx = new ParserContext(); ctx.setStrictTypeEnforcement(false); ctx.setStrongTyping(false); ctx.addImport(Foo.class); ExpressionCompiler compiler = new ExpressionCompiler("new Foo244( $bar, $bar.age );", ctx); Serializable compiled = compiler.compile(); Set<String> requiredInputs = compiler.getParserContextState().getInputs().keySet(); assertEquals(1, requiredInputs.size()); assertTrue(requiredInputs.contains("$bar")); }
@Test public void testDebugSymbolCount() { String expr = "System.out.println( \"a1\" );\n" + "System.out.println( \"a2\" );\n" + "System.out.println( \"a3\" );\n" + "System.out.println( \"a4\" );\n"; ParserContext context = new ParserContext(); context.setDebugSymbols( true ); context.addImport( "System", System.class ); context.setStrictTypeEnforcement( true ); //context.setDebugSymbols( true ); context.setSourceFile( "mysource" ); ExpressionCompiler compiler = new ExpressionCompiler( expr, context ); Serializable compiledExpression = compiler.compile(); String s = DebugTools.decompile( compiledExpression ); System.out.println( "s " + s ); int fromIndex = 0; int count = 0; while ( (fromIndex = s.indexOf( "DEBUG_SYMBOL", fromIndex + 1 )) > -1 ) { count++; } assertEquals( 4, count ); }
public void testStrictTypingCompilation4() throws NoSuchMethodException { ParserContext ctx = new ParserContext(); ctx.addImport(Foo.class); ctx.setStrictTypeEnforcement(true); ExpressionCompiler compiler = new ExpressionCompiler("x_a = new Foo()", ctx); compiler.compile(); assertEquals(Foo.class, ctx.getVariables().get("x_a")); }
public void testMethodReturningPrimitiveTypeAnalysis() { String str = "value"; ParserConfiguration pconf = new ParserConfiguration(); ParserContext pctx = new ParserContext(pconf); pctx.addInput("this", MyObj.class); pctx.setStrongTyping(true); Class<?> returnType = MVEL.analyze(str, pctx); assertEquals(long.class, returnType); }
public void testNoScopeLeakageCompiled() { String ex = "if (true) { var i = 0 }; i"; try { MVEL.compileExpression(ex, ParserContext.create().stronglyTyped()); fail("should have failed"); } catch (Exception e) { e.printStackTrace(); } } }