You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2020/10/02 10:35:05 UTC
[camel] branch master updated (c636338 -> 6076b39)
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git.
from c636338 CAMEL-15591 - Put a configurable limit on the size of unzipped data using camel-zipfile + camel-tarfile (#4314)
new 502f579 CAMEL-15606: camel-core - Simple with bean function should resolve language once
new d8da8cc CAMEL-15605: Languages should be singleton for better performance.
new eedd9a8 CAMEL-15606: camel-core - Simple with bean function should resolve language once
new 6076b39 CAMEL-15606: camel-core - Simple with bean function should resolve language once
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../reifier/language/SimpleExpressionReifier.java | 2 +
.../camel/language/simple/BaseSimpleParser.java | 5 +-
.../language/simple/SimpleExpressionParser.java | 7 +-
.../camel/language/simple/SimpleLanguage.java | 14 +++-
.../language/simple/SimplePredicateParser.java | 8 ++-
.../language/simple/ast/BinaryExpression.java | 72 ++++++++++++---------
.../language/simple/ast/BooleanExpression.java | 5 +-
.../camel/language/simple/ast/CompositeNodes.java | 7 +-
.../camel/language/simple/ast/DoubleQuoteEnd.java | 3 +-
.../language/simple/ast/DoubleQuoteStart.java | 5 +-
.../language/simple/ast/LiteralExpression.java | 3 +-
.../language/simple/ast/LogicalExpression.java | 7 +-
.../camel/language/simple/ast/NullExpression.java | 27 ++++----
.../language/simple/ast/NumericExpression.java | 3 +-
.../language/simple/ast/SimpleFunctionEnd.java | 3 +-
.../simple/ast/SimpleFunctionExpression.java | 16 +++--
.../language/simple/ast/SimpleFunctionStart.java | 17 ++---
.../camel/language/simple/ast/SimpleNode.java | 4 +-
.../camel/language/simple/ast/SingleQuoteEnd.java | 3 +-
.../language/simple/ast/SingleQuoteStart.java | 5 +-
.../camel/language/simple/ast/UnaryExpression.java | 21 +++---
.../file/FileConsumerFileExpressionTest.java | 4 +-
.../component/file/FileProducerExpressionTest.java | 4 +-
.../apache/camel/language/FileLanguageTest.java | 5 +-
.../simple/SimpleBackwardsCompatibleTest.java | 6 +-
.../simple/SimpleParserExpressionInvalidTest.java | 10 +--
.../simple/SimpleParserExpressionTest.java | 47 +++++++-------
.../simple/SimpleParserPredicateInvalidTest.java | 16 +++--
.../language/simple/SimpleParserPredicateTest.java | 51 ++++++++-------
.../simple/SimpleParserRegexpPredicateTest.java | 3 +-
.../apache/camel/language/simple/SimpleTest.java | 75 +++++++++++-----------
.../camel/support/builder/ExpressionBuilder.java | 21 ++++++
.../ROOT/pages/camel-3x-upgrade-guide-3_6.adoc | 6 ++
33 files changed, 283 insertions(+), 202 deletions(-)
[camel] 04/04: CAMEL-15606: camel-core - Simple with bean function
should resolve language once
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 6076b39926746cc4ae5102e28571ffb0c3154af0
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Fri Oct 2 12:27:01 2020 +0200
CAMEL-15606: camel-core - Simple with bean function should resolve language once
---
.../reifier/language/SimpleExpressionReifier.java | 2 +
.../camel/language/simple/SimpleLanguage.java | 8 ++-
.../simple/ast/SimpleFunctionExpression.java | 5 +-
.../file/FileConsumerFileExpressionTest.java | 4 +-
.../component/file/FileProducerExpressionTest.java | 4 +-
.../apache/camel/language/FileLanguageTest.java | 5 +-
.../apache/camel/language/simple/SimpleTest.java | 75 +++++++++++-----------
.../camel/support/builder/ExpressionBuilder.java | 21 ++++++
8 files changed, 77 insertions(+), 47 deletions(-)
diff --git a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
index e14bf79..66e1b78 100644
--- a/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
+++ b/core/camel-core-engine/src/main/java/org/apache/camel/reifier/language/SimpleExpressionReifier.java
@@ -72,6 +72,8 @@ public class SimpleExpressionReifier extends ExpressionReifier<SimpleExpression>
exp = exp.trim();
}
SimpleBuilder answer = new SimpleBuilder(exp);
+ // need to configure result type which can be set via xml dsl vs java dsl
+ configureLanguage(null);
answer.setResultType(definition.getResultType());
return answer;
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
index b7e05ce..6c0415f 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
@@ -72,7 +72,9 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
@Override
public void start() {
- // noop
+ if (getCamelContext() != null) {
+ SIMPLE.setCamelContext(getCamelContext());
+ }
}
@Override
@@ -143,6 +145,7 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
* <b>Important:</b> If you need to use a predicate (function to return true|false) then use
* {@link #predicate(String)} instead.
*/
+ @Deprecated
public static Expression simple(String expression) {
return expression(expression);
}
@@ -151,6 +154,7 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
* Creates a new {@link Expression} (or {@link Predicate} if the resultType is a <tt>Boolean</tt>, or
* <tt>boolean</tt> type).
*/
+ @Deprecated
public static Expression simple(String expression, Class<?> resultType) {
return new SimpleLanguage().createExpression(expression, resultType);
}
@@ -175,6 +179,7 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
* <b>Important:</b> If you need to use a predicate (function to return true|false) then use
* {@link #predicate(String)} instead.
*/
+ @Deprecated
public static Expression expression(String expression) {
return SIMPLE.createExpression(expression);
}
@@ -182,6 +187,7 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
/**
* Creates a new {@link Predicate}.
*/
+ @Deprecated
public static Predicate predicate(String predicate) {
return SIMPLE.createPredicate(predicate);
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
index 12ddf6c..db79f6c 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
@@ -23,6 +23,7 @@ import org.apache.camel.Expression;
import org.apache.camel.language.simple.SimpleExpressionBuilder;
import org.apache.camel.language.simple.types.SimpleParserException;
import org.apache.camel.language.simple.types.SimpleToken;
+import org.apache.camel.spi.Language;
import org.apache.camel.support.builder.ExpressionBuilder;
import org.apache.camel.util.ObjectHelper;
import org.apache.camel.util.OgnlHelper;
@@ -206,7 +207,9 @@ public class SimpleFunctionExpression extends LiteralExpression {
// bean: prefix
remainder = ifStartsWithReturnRemainder("bean:", function);
if (remainder != null) {
- return ExpressionBuilder.beanExpression(remainder);
+ // resolve bean language early
+ Language bean = camelContext.resolveLanguage("bean");
+ return ExpressionBuilder.languageExpression("bean", bean, remainder);
}
// properties: prefix
diff --git a/core/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerFileExpressionTest.java b/core/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerFileExpressionTest.java
index 53e7f09..ba48a33 100644
--- a/core/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerFileExpressionTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerFileExpressionTest.java
@@ -24,8 +24,6 @@ import org.apache.camel.spi.Registry;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import static org.apache.camel.language.simple.SimpleLanguage.simple;
-
/**
* Unit test for expression option for file consumer.
*/
@@ -74,7 +72,7 @@ public class FileConsumerFileExpressionTest extends ContextTestSupport {
template.sendBodyAndHeader("file://target/data/filelanguage/date", "Hello World", Exchange.FILE_NAME,
"myfile-20081129.txt");
template.sendBodyAndHeader("file://target/data/filelanguage/date", "Goodday World", Exchange.FILE_NAME,
- simple("myfile-${date:now:yyyyMMdd}.txt"));
+ context.resolveLanguage("simple").createExpression("myfile-${date:now:yyyyMMdd}.txt"));
context.addRoutes(new RouteBuilder() {
@Override
diff --git a/core/camel-core/src/test/java/org/apache/camel/component/file/FileProducerExpressionTest.java b/core/camel-core/src/test/java/org/apache/camel/component/file/FileProducerExpressionTest.java
index b7d5b47..1465601 100644
--- a/core/camel-core/src/test/java/org/apache/camel/component/file/FileProducerExpressionTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/component/file/FileProducerExpressionTest.java
@@ -26,8 +26,6 @@ import org.apache.camel.spi.Registry;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import static org.apache.camel.language.simple.SimpleLanguage.simple;
-
/**
* Unit test for expression option for file producer.
*/
@@ -66,7 +64,7 @@ public class FileProducerExpressionTest extends ContextTestSupport {
@Test
public void testProducerDateByHeader() throws Exception {
template.sendBodyAndHeader("file://target/data/filelanguage", "Hello World", Exchange.FILE_NAME,
- simple("myfile-${date:now:yyyyMMdd}.txt"));
+ context.resolveLanguage("simple").createExpression("myfile-${date:now:yyyyMMdd}.txt"));
String date = new SimpleDateFormat("yyyyMMdd").format(new Date());
assertFileExists("target/data/filelanguage/myfile-" + date + ".txt");
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/FileLanguageTest.java b/core/camel-core/src/test/java/org/apache/camel/language/FileLanguageTest.java
index a861d60..c935b1b 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/FileLanguageTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/FileLanguageTest.java
@@ -27,7 +27,6 @@ import org.apache.camel.LanguageTestSupport;
import org.apache.camel.component.file.FileConsumer;
import org.apache.camel.component.file.FileEndpoint;
import org.apache.camel.component.file.GenericFile;
-import org.apache.camel.language.simple.SimpleLanguage;
import org.apache.camel.spi.Registry;
import org.apache.camel.util.FileUtil;
import org.junit.jupiter.api.Test;
@@ -94,7 +93,7 @@ public class FileLanguageTest extends LanguageTestSupport {
assertExpression("${file:size}", file.length());
// modified is a long object
- Long modified = SimpleLanguage.simple("${file:modified}").evaluate(exchange, Long.class);
+ Long modified = context.resolveLanguage("simple").createExpression("${file:modified}").evaluate(exchange, Long.class);
assertEquals(file.lastModified(), modified.longValue());
}
@@ -114,7 +113,7 @@ public class FileLanguageTest extends LanguageTestSupport {
assertExpression("$simple{file:size}", file.length());
// modified is a long object
- long modified = SimpleLanguage.simple("${file:modified}").evaluate(exchange, long.class);
+ long modified = context.resolveLanguage("simple").createExpression("${file:modified}").evaluate(exchange, long.class);
assertEquals(file.lastModified(), modified);
}
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleTest.java
index 15d6fb6..d76bc59 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleTest.java
@@ -60,37 +60,39 @@ public class SimpleTest extends LanguageTestSupport {
@Test
public void testSimpleExpressionOrPredicate() throws Exception {
- Predicate predicate = SimpleLanguage.predicate("${header.bar} == 123");
+ Predicate predicate = context.resolveLanguage("simple").createPredicate("${header.bar} == 123");
assertTrue(predicate.matches(exchange));
- predicate = SimpleLanguage.predicate("${header.bar} == 124");
+ predicate = context.resolveLanguage("simple").createPredicate("${header.bar} == 124");
assertFalse(predicate.matches(exchange));
- Expression expression = SimpleLanguage.expression("${body}");
+ Expression expression = context.resolveLanguage("simple").createExpression("${body}");
assertEquals("<hello id='m123'>world!</hello>", expression.evaluate(exchange, String.class));
- expression = SimpleLanguage.simple("${body}");
+ expression = context.resolveLanguage("simple").createExpression("${body}");
assertEquals("<hello id='m123'>world!</hello>", expression.evaluate(exchange, String.class));
- expression = SimpleLanguage.simple("${body}", String.class);
+ expression = context.resolveLanguage("simple").createExpression("${body}");
assertEquals("<hello id='m123'>world!</hello>", expression.evaluate(exchange, String.class));
- expression = SimpleLanguage.simple("${header.bar} == 123", boolean.class);
- assertEquals(Boolean.TRUE, expression.evaluate(exchange, Object.class));
- expression = SimpleLanguage.simple("${header.bar} == 124", boolean.class);
- assertEquals(Boolean.FALSE, expression.evaluate(exchange, Object.class));
- expression = SimpleLanguage.simple("${header.bar} == 123", Boolean.class);
- assertEquals(Boolean.TRUE, expression.evaluate(exchange, Object.class));
- expression = SimpleLanguage.simple("${header.bar} == 124", Boolean.class);
- assertEquals(Boolean.FALSE, expression.evaluate(exchange, Object.class));
+ predicate = context.resolveLanguage("simple").createPredicate("${header.bar} == 123");
+ assertEquals(Boolean.TRUE, predicate.matches(exchange));
+ predicate = context.resolveLanguage("simple").createPredicate("${header.bar} == 124");
+ assertEquals(Boolean.FALSE, predicate.matches(exchange));
+ predicate = context.resolveLanguage("simple").createPredicate("${header.bar} == 123");
+ assertEquals(Boolean.TRUE, predicate.matches(exchange));
+ predicate = context.resolveLanguage("simple").createPredicate("${header.bar} == 124");
+ assertEquals(Boolean.FALSE, predicate.matches(exchange));
}
@Test
public void testResultType() throws Exception {
- assertEquals(123, SimpleLanguage.simple("${header.bar}", int.class).evaluate(exchange, Object.class));
- assertEquals("123", SimpleLanguage.simple("${header.bar}", String.class).evaluate(exchange, Object.class));
+ assertEquals(123, context.resolveLanguage("simple").createExpression("${header.bar}").evaluate(exchange, int.class));
+ assertEquals("123",
+ context.resolveLanguage("simple").createExpression("${header.bar}").evaluate(exchange, String.class));
// should not be possible
- assertEquals(null, SimpleLanguage.simple("${header.bar}", Date.class).evaluate(exchange, Object.class));
- assertEquals(null, SimpleLanguage.simple("${header.unknown}", String.class).evaluate(exchange, Object.class));
+ assertEquals(null, context.resolveLanguage("simple").createExpression("${header.bar}").evaluate(exchange, Date.class));
+ assertEquals(null,
+ context.resolveLanguage("simple").createExpression("${header.unknown}").evaluate(exchange, String.class));
}
@Test
@@ -110,7 +112,7 @@ public class SimpleTest extends LanguageTestSupport {
@Test
public void testNull() throws Exception {
- assertNull(SimpleLanguage.simple("${null}").evaluate(exchange, Object.class));
+ assertNull(context.resolveLanguage("simple").createExpression("${null}").evaluate(exchange, Object.class));
}
@Test
@@ -141,7 +143,7 @@ public class SimpleTest extends LanguageTestSupport {
@Test
public void testExchangeExpression() throws Exception {
- Expression exp = SimpleLanguage.simple("${exchange}");
+ Expression exp = context.resolveLanguage("simple").createExpression("${exchange}");
assertNotNull(exp);
assertEquals(exchange, exp.evaluate(exchange, Object.class));
@@ -150,7 +152,7 @@ public class SimpleTest extends LanguageTestSupport {
@Test
public void testExchangeOgnlExpression() throws Exception {
- Expression exp = SimpleLanguage.simple("${exchange.exchangeId}");
+ Expression exp = context.resolveLanguage("simple").createExpression("${exchange.exchangeId}");
assertNotNull(exp);
assertEquals(exchange.getExchangeId(), exp.evaluate(exchange, Object.class));
@@ -160,18 +162,18 @@ public class SimpleTest extends LanguageTestSupport {
@Test
public void testBodyExpression() throws Exception {
- Expression exp = SimpleLanguage.simple("${body}");
+ Expression exp = context.resolveLanguage("simple").createExpression("${body}");
assertNotNull(exp);
}
@Test
public void testBodyOgnlExpression() throws Exception {
- Expression exp = SimpleLanguage.simple("${body.xxx}");
+ Expression exp = context.resolveLanguage("simple").createExpression("${body.xxx}");
assertNotNull(exp);
// must start with a dot
try {
- SimpleLanguage.simple("${bodyxxx}");
+ context.resolveLanguage("simple").createExpression("${bodyxxx}");
fail("Should throw exception");
} catch (SimpleIllegalSyntaxException e) {
// expected
@@ -180,14 +182,14 @@ public class SimpleTest extends LanguageTestSupport {
@Test
public void testBodyExpressionUsingAlternativeStartToken() throws Exception {
- Expression exp = SimpleLanguage.simple("$simple{body}");
+ Expression exp = context.resolveLanguage("simple").createExpression("$simple{body}");
assertNotNull(exp);
}
@Test
public void testBodyExpressionNotStringType() throws Exception {
exchange.getIn().setBody(123);
- Expression exp = SimpleLanguage.simple("${body}");
+ Expression exp = context.resolveLanguage("simple").createExpression("${body}");
assertNotNull(exp);
Object val = exp.evaluate(exchange, Object.class);
assertIsInstanceOf(Integer.class, val);
@@ -197,12 +199,12 @@ public class SimpleTest extends LanguageTestSupport {
@Test
public void testBodyExpressionWithArray() throws Exception {
exchange.getIn().setBody(new MyClass());
- Expression exp = SimpleLanguage.simple("${body.myArray}");
+ Expression exp = context.resolveLanguage("simple").createExpression("${body.myArray}");
assertNotNull(exp);
Object val = exp.evaluate(exchange, Object.class);
assertIsInstanceOf(Object[].class, val);
- exp = SimpleLanguage.simple("${body.myArray.length}");
+ exp = context.resolveLanguage("simple").createExpression("${body.myArray.length}");
assertNotNull(exp);
val = exp.evaluate(exchange, Object.class);
assertIsInstanceOf(Integer.class, val);
@@ -702,7 +704,8 @@ public class SimpleTest extends LanguageTestSupport {
public void testExceptionStacktrace() throws Exception {
exchange.setException(new IllegalArgumentException("Just testing"));
- String out = SimpleLanguage.simple("${exception.stacktrace}").evaluate(exchange, String.class);
+ String out = context.resolveLanguage("simple").createExpression("${exception.stacktrace}").evaluate(exchange,
+ String.class);
assertNotNull(out);
assertTrue(out.startsWith("java.lang.IllegalArgumentException: Just testing"));
assertTrue(out.contains("at org.apache.camel.language."));
@@ -712,7 +715,7 @@ public class SimpleTest extends LanguageTestSupport {
public void testException() throws Exception {
exchange.setException(new IllegalArgumentException("Just testing"));
- Exception out = SimpleLanguage.simple("${exception}").evaluate(exchange, Exception.class);
+ Exception out = context.resolveLanguage("simple").createExpression("${exception}").evaluate(exchange, Exception.class);
assertNotNull(out);
assertIsInstanceOf(IllegalArgumentException.class, out);
assertEquals("Just testing", out.getMessage());
@@ -1826,18 +1829,18 @@ public class SimpleTest extends LanguageTestSupport {
int iterations = 30;
int i = 0;
for (i = 0; i < iterations; i++) {
- Expression expression = SimpleLanguage.simple("${random(1,10)}", Integer.class);
+ Expression expression = context.resolveLanguage("simple").createExpression("${random(1,10)}");
assertTrue(
min <= expression.evaluate(exchange, Integer.class) && expression.evaluate(exchange, Integer.class) < max);
}
for (i = 0; i < iterations; i++) {
- Expression expression = SimpleLanguage.simple("${random(10)}", Integer.class);
+ Expression expression = context.resolveLanguage("simple").createExpression("${random(10)}");
assertTrue(0 <= expression.evaluate(exchange, Integer.class) && expression.evaluate(exchange, Integer.class) < max);
}
- Expression expression = SimpleLanguage.simple("${random(1, 10)}", Integer.class);
+ Expression expression = context.resolveLanguage("simple").createExpression("${random(1, 10)}");
assertTrue(min <= expression.evaluate(exchange, Integer.class) && expression.evaluate(exchange, Integer.class) < max);
- Expression expression1 = SimpleLanguage.simple("${random( 10)}", Integer.class);
+ Expression expression1 = context.resolveLanguage("simple").createExpression("${random( 10)}");
assertTrue(0 <= expression1.evaluate(exchange, Integer.class) && expression1.evaluate(exchange, Integer.class) < max);
try {
@@ -1854,7 +1857,7 @@ public class SimpleTest extends LanguageTestSupport {
}
exchange.getIn().setHeader("max", 20);
- Expression expression3 = SimpleLanguage.simple("${random(10,${header.max})}", Integer.class);
+ Expression expression3 = context.resolveLanguage("simple").createExpression("${random(10,${header.max})}");
int num = expression3.evaluate(exchange, Integer.class);
assertTrue(num >= 0 && num < 20, "Should be 10..20");
}
@@ -1868,7 +1871,7 @@ public class SimpleTest extends LanguageTestSupport {
assertEquals(2, data.size());
- Expression expression = SimpleLanguage.simple("${body.remove('A')}");
+ Expression expression = context.resolveLanguage("simple").createExpression("${body.remove('A')}");
expression.evaluate(exchange, Object.class);
assertEquals(1, data.size());
@@ -1884,7 +1887,7 @@ public class SimpleTest extends LanguageTestSupport {
assertEquals(2, data.size());
- Expression expression = SimpleLanguage.simple("${body.remove(0)}");
+ Expression expression = context.resolveLanguage("simple").createExpression("${body.remove(0)}");
expression.evaluate(exchange, Object.class);
assertEquals(1, data.size());
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/builder/ExpressionBuilder.java b/core/camel-support/src/main/java/org/apache/camel/support/builder/ExpressionBuilder.java
index c180124..7c2997e 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/builder/ExpressionBuilder.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/builder/ExpressionBuilder.java
@@ -668,6 +668,27 @@ public class ExpressionBuilder {
/**
* Returns an expression for evaluating the expression/predicate using the given language
*
+ * @param languageName the language name
+ * @param language the language
+ * @param expression the expression or predicate
+ * @return an expression object which will evaluate the expression/predicate using the given language
+ */
+ public static Expression languageExpression(final String languageName, final Language language, final String expression) {
+ return new ExpressionAdapter() {
+ public Object evaluate(Exchange exchange) {
+ return language.createExpression(expression).evaluate(exchange, Object.class);
+ }
+
+ @Override
+ public String toString() {
+ return languageName + "(" + expression + ")";
+ }
+ };
+ }
+
+ /**
+ * Returns an expression for evaluating the expression/predicate using the given language
+ *
* @param expression the expression or predicate
* @return an expression object which will evaluate the expression/predicate using the given language
*/
[camel] 01/04: CAMEL-15606: camel-core - Simple with bean function
should resolve language once
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 502f579f2f67a7aa84e9500183a0146071045cfa
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Fri Oct 2 11:21:26 2020 +0200
CAMEL-15606: camel-core - Simple with bean function should resolve language once
---
.../camel/impl/engine/AbstractCamelContext.java | 1 +
.../camel/language/simple/BaseSimpleParser.java | 5 +-
.../language/simple/SimpleExpressionParser.java | 7 ++-
.../camel/language/simple/SimpleLanguage.java | 4 +-
.../language/simple/SimplePredicateParser.java | 7 ++-
.../language/simple/ast/BinaryExpression.java | 65 +++++++++++-----------
.../language/simple/ast/BooleanExpression.java | 5 +-
.../camel/language/simple/ast/CompositeNodes.java | 7 ++-
.../camel/language/simple/ast/DoubleQuoteEnd.java | 3 +-
.../language/simple/ast/DoubleQuoteStart.java | 5 +-
.../language/simple/ast/LiteralExpression.java | 3 +-
.../language/simple/ast/LogicalExpression.java | 7 ++-
.../camel/language/simple/ast/NullExpression.java | 27 +++++----
.../language/simple/ast/NumericExpression.java | 3 +-
.../language/simple/ast/SimpleFunctionEnd.java | 3 +-
.../simple/ast/SimpleFunctionExpression.java | 21 +++----
.../language/simple/ast/SimpleFunctionStart.java | 17 +++---
.../camel/language/simple/ast/SimpleNode.java | 8 ++-
.../camel/language/simple/ast/SingleQuoteEnd.java | 3 +-
.../language/simple/ast/SingleQuoteStart.java | 5 +-
.../camel/language/simple/ast/UnaryExpression.java | 21 +++----
.../simple/SimpleBackwardsCompatibleTest.java | 4 +-
.../simple/SimpleParserExpressionInvalidTest.java | 10 ++--
.../simple/SimpleParserExpressionTest.java | 44 +++++++--------
.../simple/SimpleParserPredicateInvalidTest.java | 14 ++---
.../language/simple/SimpleParserPredicateTest.java | 50 ++++++++---------
.../simple/SimpleParserRegexpPredicateTest.java | 2 +-
27 files changed, 188 insertions(+), 163 deletions(-)
diff --git a/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index 93c92b5..8e4e940 100644
--- a/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -1638,6 +1638,7 @@ public abstract class AbstractCamelContext extends BaseService
@Override
public Language resolveLanguage(String language) {
LOG.debug("Resolving language: {}", language);
+ System.out.println("Resolving language: " + language);
Language answer;
synchronized (languages) {
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/BaseSimpleParser.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/BaseSimpleParser.java
index f57aeb6..5214eda 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/BaseSimpleParser.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/BaseSimpleParser.java
@@ -22,6 +22,7 @@ import java.util.Collections;
import java.util.Deque;
import java.util.List;
+import org.apache.camel.CamelContext;
import org.apache.camel.language.simple.ast.Block;
import org.apache.camel.language.simple.ast.BlockEnd;
import org.apache.camel.language.simple.ast.BlockStart;
@@ -40,6 +41,7 @@ import org.apache.camel.language.simple.types.TokenType;
*/
public abstract class BaseSimpleParser {
+ protected CamelContext camelContext;
protected final String expression;
protected final List<SimpleToken> tokens = new ArrayList<>();
protected final List<SimpleNode> nodes = new ArrayList<>();
@@ -48,7 +50,8 @@ public abstract class BaseSimpleParser {
protected int index;
protected boolean allowEscape;
- protected BaseSimpleParser(String expression, boolean allowEscape) {
+ protected BaseSimpleParser(CamelContext camelContext, String expression, boolean allowEscape) {
+ this.camelContext = camelContext;
this.expression = expression;
this.allowEscape = allowEscape;
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionParser.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionParser.java
index 7b50084..6b88e1b 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionParser.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionParser.java
@@ -21,6 +21,7 @@ import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.ast.LiteralExpression;
import org.apache.camel.language.simple.ast.LiteralNode;
@@ -42,9 +43,9 @@ public class SimpleExpressionParser extends BaseSimpleParser {
// use caches to avoid re-parsing the same expressions over and over again
private Map<String, Expression> cacheExpression;
- public SimpleExpressionParser(String expression, boolean allowEscape,
+ public SimpleExpressionParser(CamelContext camelContext, String expression, boolean allowEscape,
Map<String, Expression> cacheExpression) {
- super(expression, allowEscape);
+ super(camelContext, expression, allowEscape);
this.cacheExpression = cacheExpression;
}
@@ -161,7 +162,7 @@ public class SimpleExpressionParser extends BaseSimpleParser {
private List<Expression> createExpressions() {
List<Expression> answer = new ArrayList<>();
for (SimpleNode token : nodes) {
- Expression exp = token.createExpression(expression);
+ Expression exp = token.createExpression(camelContext, expression);
if (exp != null) {
answer.add(exp);
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
index 5466d58..2f1e16d 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
@@ -104,7 +104,7 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
expression = loadResource(expression);
- SimplePredicateParser parser = new SimplePredicateParser(expression, allowEscape, cacheExpression);
+ SimplePredicateParser parser = new SimplePredicateParser(getCamelContext(), expression, allowEscape, cacheExpression);
answer = parser.parsePredicate();
if (cachePredicate != null && answer != null) {
@@ -124,7 +124,7 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
expression = loadResource(expression);
- SimpleExpressionParser parser = new SimpleExpressionParser(expression, allowEscape, cacheExpression);
+ SimpleExpressionParser parser = new SimpleExpressionParser(getCamelContext(), expression, allowEscape, cacheExpression);
answer = parser.parseExpression();
if (cacheExpression != null && answer != null) {
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimplePredicateParser.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimplePredicateParser.java
index 226aae2..392953b 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimplePredicateParser.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimplePredicateParser.java
@@ -25,6 +25,7 @@ import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
import org.apache.camel.language.simple.ast.BinaryExpression;
@@ -62,8 +63,8 @@ public class SimplePredicateParser extends BaseSimpleParser {
// use caches to avoid re-parsing the same expressions over and over again
private Map<String, Expression> cacheExpression;
- public SimplePredicateParser(String expression, boolean allowEscape, Map<String, Expression> cacheExpression) {
- super(expression, allowEscape);
+ public SimplePredicateParser(CamelContext camelContext, String expression, boolean allowEscape, Map<String, Expression> cacheExpression) {
+ super(camelContext, expression, allowEscape);
this.cacheExpression = cacheExpression;
}
@@ -467,7 +468,7 @@ public class SimplePredicateParser extends BaseSimpleParser {
private List<Predicate> createPredicates() {
List<Predicate> answer = new ArrayList<>();
for (SimpleNode node : nodes) {
- Expression exp = node.createExpression(expression);
+ Expression exp = node.createExpression(camelContext, expression);
if (exp != null) {
Predicate predicate = ExpressionToPredicateAdapter.toPredicate(exp);
answer.add(predicate);
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BinaryExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BinaryExpression.java
index cf5c54a..f0fbaeb 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BinaryExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BinaryExpression.java
@@ -22,6 +22,7 @@ import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
@@ -71,57 +72,57 @@ public class BinaryExpression extends BaseSimpleNode {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
org.apache.camel.util.ObjectHelper.notNull(left, "left node", this);
org.apache.camel.util.ObjectHelper.notNull(right, "right node", this);
- final Expression leftExp = left.createExpression(expression);
- final Expression rightExp = right.createExpression(expression);
+ final Expression leftExp = left.createExpression(camelContext, expression);
+ final Expression rightExp = right.createExpression(camelContext, expression);
if (operator == BinaryOperatorType.EQ) {
- return createExpression(leftExp, rightExp, PredicateBuilder.isEqualTo(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isEqualTo(leftExp, rightExp));
} else if (operator == BinaryOperatorType.EQ_IGNORE) {
- return createExpression(leftExp, rightExp, PredicateBuilder.isEqualToIgnoreCase(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isEqualToIgnoreCase(leftExp, rightExp));
} else if (operator == BinaryOperatorType.GT) {
- return createExpression(leftExp, rightExp, PredicateBuilder.isGreaterThan(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isGreaterThan(leftExp, rightExp));
} else if (operator == BinaryOperatorType.GTE) {
- return createExpression(leftExp, rightExp, PredicateBuilder.isGreaterThanOrEqualTo(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isGreaterThanOrEqualTo(leftExp, rightExp));
} else if (operator == BinaryOperatorType.LT) {
- return createExpression(leftExp, rightExp, PredicateBuilder.isLessThan(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isLessThan(leftExp, rightExp));
} else if (operator == BinaryOperatorType.LTE) {
- return createExpression(leftExp, rightExp, PredicateBuilder.isLessThanOrEqualTo(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isLessThanOrEqualTo(leftExp, rightExp));
} else if (operator == BinaryOperatorType.NOT_EQ) {
- return createExpression(leftExp, rightExp, PredicateBuilder.isNotEqualTo(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isNotEqualTo(leftExp, rightExp));
} else if (operator == BinaryOperatorType.NOT_EQ_IGNORE) {
- return createExpression(leftExp, rightExp,
+ return createExpression(camelContext, leftExp, rightExp,
PredicateBuilder.not(PredicateBuilder.isEqualToIgnoreCase(leftExp, rightExp)));
} else if (operator == BinaryOperatorType.CONTAINS) {
- return createExpression(leftExp, rightExp, PredicateBuilder.contains(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.contains(leftExp, rightExp));
} else if (operator == BinaryOperatorType.NOT_CONTAINS) {
- return createExpression(leftExp, rightExp, PredicateBuilder.not(PredicateBuilder.contains(leftExp, rightExp)));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.not(PredicateBuilder.contains(leftExp, rightExp)));
} else if (operator == BinaryOperatorType.CONTAINS_IGNORECASE) {
- return createExpression(leftExp, rightExp, PredicateBuilder.containsIgnoreCase(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.containsIgnoreCase(leftExp, rightExp));
} else if (operator == BinaryOperatorType.NOT_CONTAINS_IGNORECASE) {
- return createExpression(leftExp, rightExp,
+ return createExpression(camelContext, leftExp, rightExp,
PredicateBuilder.not(PredicateBuilder.containsIgnoreCase(leftExp, rightExp)));
} else if (operator == BinaryOperatorType.IS || operator == BinaryOperatorType.NOT_IS) {
- return createIsExpression(expression, leftExp, rightExp);
+ return createIsExpression(camelContext, expression, leftExp, rightExp);
} else if (operator == BinaryOperatorType.REGEX || operator == BinaryOperatorType.NOT_REGEX) {
- return createRegexExpression(leftExp, rightExp);
+ return createRegexExpression(camelContext, leftExp, rightExp);
} else if (operator == BinaryOperatorType.IN || operator == BinaryOperatorType.NOT_IN) {
- return createInExpression(leftExp, rightExp);
+ return createInExpression(camelContext, leftExp, rightExp);
} else if (operator == BinaryOperatorType.RANGE || operator == BinaryOperatorType.NOT_RANGE) {
- return createRangeExpression(expression, leftExp, rightExp);
+ return createRangeExpression(camelContext, expression, leftExp, rightExp);
} else if (operator == BinaryOperatorType.STARTS_WITH) {
- return createExpression(leftExp, rightExp, PredicateBuilder.startsWith(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.startsWith(leftExp, rightExp));
} else if (operator == BinaryOperatorType.ENDS_WITH) {
- return createExpression(leftExp, rightExp, PredicateBuilder.endsWith(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.endsWith(leftExp, rightExp));
}
throw new SimpleParserException("Unknown binary operator " + operator, token.getIndex());
}
- private Expression createIsExpression(final String expression, final Expression leftExp, final Expression rightExp) {
+ private Expression createIsExpression(final CamelContext camelContext, final String expression, final Expression leftExp, final Expression rightExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -132,7 +133,7 @@ public class BinaryExpression extends BaseSimpleNode {
expression, right.getToken().getIndex(),
operator + " operator cannot accept null. A class type must be provided.");
}
- Class<?> rightType = exchange.getContext().getClassResolver().resolveClass(name);
+ Class<?> rightType = camelContext.getClassResolver().resolveClass(name);
if (rightType == null) {
throw new SimpleIllegalSyntaxException(
expression, right.getToken().getIndex(),
@@ -145,7 +146,7 @@ public class BinaryExpression extends BaseSimpleNode {
}
boolean answer = predicate.matches(exchange);
- return exchange.getContext().getTypeConverter().convertTo(type, answer);
+ return camelContext.getTypeConverter().convertTo(type, answer);
}
@Override
@@ -155,7 +156,7 @@ public class BinaryExpression extends BaseSimpleNode {
};
}
- private Expression createRegexExpression(final Expression leftExp, final Expression rightExp) {
+ private Expression createRegexExpression(final CamelContext camelContext, final Expression leftExp, final Expression rightExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -165,7 +166,7 @@ public class BinaryExpression extends BaseSimpleNode {
predicate = PredicateBuilder.not(predicate);
}
boolean answer = predicate.matches(exchange);
- return exchange.getContext().getTypeConverter().convertTo(type, answer);
+ return camelContext.getTypeConverter().convertTo(type, answer);
}
@Override
@@ -175,7 +176,7 @@ public class BinaryExpression extends BaseSimpleNode {
};
}
- private Expression createInExpression(final Expression leftExp, final Expression rightExp) {
+ private Expression createInExpression(final CamelContext camelContext, final Expression leftExp, final Expression rightExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -194,7 +195,7 @@ public class BinaryExpression extends BaseSimpleNode {
predicate = PredicateBuilder.not(predicate);
}
boolean answer = predicate.matches(exchange);
- return exchange.getContext().getTypeConverter().convertTo(type, answer);
+ return camelContext.getTypeConverter().convertTo(type, answer);
}
@Override
@@ -204,7 +205,7 @@ public class BinaryExpression extends BaseSimpleNode {
};
}
- private Expression createRangeExpression(final String expression, final Expression leftExp, final Expression rightExp) {
+ private Expression createRangeExpression(final CamelContext camelContext, final String expression, final Expression leftExp, final Expression rightExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -230,7 +231,7 @@ public class BinaryExpression extends BaseSimpleNode {
}
boolean answer = predicate.matches(exchange);
- return exchange.getContext().getTypeConverter().convertTo(type, answer);
+ return camelContext.getTypeConverter().convertTo(type, answer);
}
@Override
@@ -240,12 +241,12 @@ public class BinaryExpression extends BaseSimpleNode {
};
}
- private Expression createExpression(final Expression left, final Expression right, final Predicate predicate) {
+ private Expression createExpression(final CamelContext camelContext, final Expression left, final Expression right, final Predicate predicate) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
boolean answer = predicate.matches(exchange);
- return exchange.getContext().getTypeConverter().convertTo(type, answer);
+ return camelContext.getTypeConverter().convertTo(type, answer);
}
@Override
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BooleanExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BooleanExpression.java
index 5c662ee..cf7e3d0 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BooleanExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BooleanExpression.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleParserException;
@@ -34,14 +35,14 @@ public class BooleanExpression extends BaseSimpleNode {
}
@Override
- public Expression createExpression(String expression) throws SimpleParserException {
+ public Expression createExpression(CamelContext camelContext, String expression) throws SimpleParserException {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
if (type == Object.class || type == Boolean.class || type == boolean.class) {
return (T) Boolean.valueOf(value);
}
- return exchange.getContext().getTypeConverter().tryConvertTo(type, exchange, value);
+ return camelContext.getTypeConverter().tryConvertTo(type, exchange, value);
}
@Override
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/CompositeNodes.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/CompositeNodes.java
index 7a2cfb4..d274b74 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/CompositeNodes.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/CompositeNodes.java
@@ -19,6 +19,7 @@ package org.apache.camel.language.simple.ast;
import java.util.ArrayList;
import java.util.List;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleToken;
import org.apache.camel.support.builder.ExpressionBuilder;
@@ -52,15 +53,15 @@ public class CompositeNodes extends BaseSimpleNode {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
if (children.isEmpty()) {
return null;
} else if (children.size() == 1) {
- return children.get(0).createExpression(expression);
+ return children.get(0).createExpression(camelContext, expression);
} else {
List<Expression> answer = new ArrayList<>();
for (SimpleNode child : children) {
- answer.add(child.createExpression(expression));
+ answer.add(child.createExpression(camelContext, expression));
}
return ExpressionBuilder.concatExpression(answer);
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/DoubleQuoteEnd.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/DoubleQuoteEnd.java
index dc161b6..62b314f 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/DoubleQuoteEnd.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/DoubleQuoteEnd.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleToken;
@@ -29,7 +30,7 @@ public class DoubleQuoteEnd extends BaseSimpleNode implements BlockEnd {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
return null;
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/DoubleQuoteStart.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/DoubleQuoteStart.java
index 3d6b23f..f5a4477 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/DoubleQuoteStart.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/DoubleQuoteStart.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleToken;
import org.apache.camel.support.builder.ExpressionBuilder;
@@ -39,10 +40,10 @@ public class DoubleQuoteStart extends BaseSimpleNode implements BlockStart {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
Expression answer = null;
if (block != null) {
- answer = block.createExpression(expression);
+ answer = block.createExpression(camelContext, expression);
}
if (answer == null) {
// there quoted literal is empty
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/LiteralExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/LiteralExpression.java
index 157668b..ca9fc19 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/LiteralExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/LiteralExpression.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleToken;
import org.apache.camel.support.builder.ExpressionBuilder;
@@ -55,7 +56,7 @@ public class LiteralExpression extends BaseSimpleNode implements LiteralNode {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
return ExpressionBuilder.constantExpression(getText());
}
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/LogicalExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/LogicalExpression.java
index d6599f1..818166c 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/LogicalExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/LogicalExpression.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
@@ -60,12 +61,12 @@ public class LogicalExpression extends BaseSimpleNode {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
ObjectHelper.notNull(left, "left node", this);
ObjectHelper.notNull(right, "right node", this);
- final Expression leftExp = left.createExpression(expression);
- final Expression rightExp = right.createExpression(expression);
+ final Expression leftExp = left.createExpression(camelContext, expression);
+ final Expression rightExp = right.createExpression(camelContext, expression);
if (operator == LogicalOperatorType.AND) {
return createAndExpression(leftExp, rightExp);
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/NullExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/NullExpression.java
index b0bceb6..83c0643 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/NullExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/NullExpression.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleParserException;
@@ -26,22 +27,24 @@ import org.apache.camel.language.simple.types.SimpleToken;
*/
public class NullExpression extends BaseSimpleNode {
+ private static final Expression NULL_EXPRESSION = new Expression() {
+ @Override
+ public <T> T evaluate(Exchange exchange, Class<T> type) {
+ return null;
+ }
+
+ @Override
+ public String toString() {
+ return "null";
+ }
+ };
+
public NullExpression(SimpleToken token) {
super(token);
}
@Override
- public Expression createExpression(String expression) throws SimpleParserException {
- return new Expression() {
- @Override
- public <T> T evaluate(Exchange exchange, Class<T> type) {
- return null;
- }
-
- @Override
- public String toString() {
- return "null";
- }
- };
+ public Expression createExpression(CamelContext camelContext, String expression) throws SimpleParserException {
+ return NULL_EXPRESSION;
}
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/NumericExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/NumericExpression.java
index d50a6d8..e87692c 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/NumericExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/NumericExpression.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleParserException;
@@ -47,7 +48,7 @@ public class NumericExpression extends BaseSimpleNode {
}
@Override
- public Expression createExpression(String expression) throws SimpleParserException {
+ public Expression createExpression(CamelContext camelContext, String expression) throws SimpleParserException {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionEnd.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionEnd.java
index e2795cf..03c71fc 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionEnd.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionEnd.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleToken;
@@ -29,7 +30,7 @@ public class SimpleFunctionEnd extends BaseSimpleNode implements BlockEnd {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
return null;
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
index 5c853f3..5f848e3 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
@@ -18,6 +18,7 @@ package org.apache.camel.language.simple.ast;
import java.util.Map;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.SimpleExpressionBuilder;
import org.apache.camel.language.simple.types.SimpleParserException;
@@ -46,12 +47,12 @@ public class SimpleFunctionExpression extends LiteralExpression {
* @param expression not in use
*/
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
String function = text.toString();
Expression answer = cacheExpression != null ? cacheExpression.get(function) : null;
if (answer == null) {
- answer = createSimpleExpression(function, true);
+ answer = createSimpleExpression(camelContext, function, true);
if (cacheExpression != null && answer != null) {
cacheExpression.put(function, answer);
}
@@ -62,19 +63,19 @@ public class SimpleFunctionExpression extends LiteralExpression {
/**
* Creates a Camel {@link Expression} based on this model.
*
- * @param expression not in use
- * @param strict whether to throw exception if the expression
- * was not a function, otherwise <tt>null</tt>
- * is returned
- * @return the created {@link Expression}
+ * @param expression not in use
+ * @param strict whether to throw exception if the expression
+ * was not a function, otherwise <tt>null</tt>
+ * is returned
+ * @return the created {@link Expression}
* @throws org.apache.camel.language.simple.types.SimpleParserException should be thrown if error parsing the model
*/
- public Expression createExpression(String expression, boolean strict) {
+ public Expression createExpression(CamelContext camelContext, String expression, boolean strict) {
String function = text.toString();
Expression answer = cacheExpression != null ? cacheExpression.get(function) : null;
if (answer == null) {
- answer = createSimpleExpression(function, strict);
+ answer = createSimpleExpression(camelContext, function, strict);
if (cacheExpression != null && answer != null) {
cacheExpression.put(function, answer);
}
@@ -82,7 +83,7 @@ public class SimpleFunctionExpression extends LiteralExpression {
return answer;
}
- private Expression createSimpleExpression(String function, boolean strict) {
+ private Expression createSimpleExpression(CamelContext camelContext, String function, boolean strict) {
// return the function directly if we can create function without analyzing the prefix
Expression answer = createSimpleExpressionDirectly(function);
if (answer != null) {
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionStart.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionStart.java
index eef11c3..d10ccdb 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionStart.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionStart.java
@@ -18,6 +18,7 @@ package org.apache.camel.language.simple.ast;
import java.util.Map;
+import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleIllegalSyntaxException;
@@ -53,23 +54,23 @@ public class SimpleFunctionStart extends BaseSimpleNode implements BlockStart {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
// a function can either be a simple literal function, or contain nested functions
if (block.getChildren().size() == 1 && block.getChildren().get(0) instanceof LiteralNode) {
- return doCreateLiteralExpression(expression);
+ return doCreateLiteralExpression(camelContext, expression);
} else {
- return doCreateCompositeExpression(expression);
+ return doCreateCompositeExpression(camelContext, expression);
}
}
- private Expression doCreateLiteralExpression(final String expression) {
+ private Expression doCreateLiteralExpression(CamelContext camelContext, String expression) {
SimpleFunctionExpression function = new SimpleFunctionExpression(this.getToken(), cacheExpression);
LiteralNode literal = (LiteralNode) block.getChildren().get(0);
function.addText(literal.getText());
- return function.createExpression(expression);
+ return function.createExpression(camelContext, expression);
}
- private Expression doCreateCompositeExpression(final String expression) {
+ private Expression doCreateCompositeExpression(CamelContext camelContext, String expression) {
final SimpleToken token = getToken();
return new Expression() {
@Override
@@ -92,7 +93,7 @@ public class SimpleFunctionStart extends BaseSimpleNode implements BlockStart {
} else if (!lazy || child instanceof SingleQuoteStart || child instanceof DoubleQuoteStart) {
try {
// pass in null when we evaluate the nested expressions
- Expression nested = child.createExpression(null);
+ Expression nested = child.createExpression(camelContext, null);
String text = nested.evaluate(exchange, String.class);
if (text != null) {
if (quoteEmbeddedFunctions && !StringHelper.isQuoted(text)) {
@@ -117,7 +118,7 @@ public class SimpleFunctionStart extends BaseSimpleNode implements BlockStart {
SimpleFunctionExpression function = new SimpleFunctionExpression(token, cacheExpression);
function.addText(exp);
try {
- return function.createExpression(exp).evaluate(exchange, type);
+ return function.createExpression(camelContext, exp).evaluate(exchange, type);
} catch (SimpleParserException e) {
// must rethrow parser exception as illegal syntax with details about the location
throw new SimpleIllegalSyntaxException(expression, e.getIndex(), e.getMessage(), e);
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleNode.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleNode.java
index 4d2ca83..afe5921 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleNode.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleNode.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleParserException;
import org.apache.camel.language.simple.types.SimpleToken;
@@ -35,10 +36,11 @@ public interface SimpleNode {
/**
* Creates a Camel {@link Expression} based on this model.
*
- * @param expression the input string
- * @return the created {@link Expression}
+ * @param camelContext the camel context
+ * @param expression the input string
+ * @return the created {@link Expression}
* @throws org.apache.camel.language.simple.types.SimpleParserException should be thrown if error parsing the model
*/
- Expression createExpression(String expression) throws SimpleParserException;
+ Expression createExpression(CamelContext camelContext, String expression) throws SimpleParserException;
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SingleQuoteEnd.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SingleQuoteEnd.java
index 43e1452..b0f590b 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SingleQuoteEnd.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SingleQuoteEnd.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleToken;
@@ -29,7 +30,7 @@ public class SingleQuoteEnd extends BaseSimpleNode implements BlockEnd {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
return null;
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SingleQuoteStart.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SingleQuoteStart.java
index a1b4158..ad484ca 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SingleQuoteStart.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SingleQuoteStart.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.Expression;
import org.apache.camel.language.simple.types.SimpleToken;
import org.apache.camel.support.builder.ExpressionBuilder;
@@ -39,10 +40,10 @@ public class SingleQuoteStart extends BaseSimpleNode implements BlockStart {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
Expression answer = null;
if (block != null) {
- answer = block.createExpression(expression);
+ answer = block.createExpression(camelContext, expression);
}
if (answer == null) {
// there quoted literal is empty
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/UnaryExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/UnaryExpression.java
index 35457ae..6d8dc16 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/UnaryExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/UnaryExpression.java
@@ -16,6 +16,7 @@
*/
package org.apache.camel.language.simple.ast;
+import org.apache.camel.CamelContext;
import org.apache.camel.CamelExchangeException;
import org.apache.camel.Exchange;
import org.apache.camel.Expression;
@@ -62,21 +63,21 @@ public class UnaryExpression extends BaseSimpleNode {
}
@Override
- public Expression createExpression(String expression) {
+ public Expression createExpression(CamelContext camelContext, String expression) {
ObjectHelper.notNull(left, "left node", this);
- final Expression leftExp = left.createExpression(expression);
+ final Expression leftExp = left.createExpression(camelContext, expression);
if (operator == UnaryOperatorType.INC) {
- return createIncExpression(leftExp);
+ return createIncExpression(camelContext, leftExp);
} else if (operator == UnaryOperatorType.DEC) {
- return createDecExpression(leftExp);
+ return createDecExpression(camelContext, leftExp);
}
throw new SimpleParserException("Unknown unary operator " + operator, token.getIndex());
}
- private Expression createIncExpression(final Expression leftExp) {
+ private Expression createIncExpression(CamelContext camelContext, final Expression leftExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -88,13 +89,13 @@ public class UnaryExpression extends BaseSimpleNode {
// convert value back to same type as input as we want to preserve type
Object left = leftExp.evaluate(exchange, Object.class);
try {
- left = exchange.getContext().getTypeConverter().mandatoryConvertTo(left.getClass(), exchange, val);
+ left = camelContext.getTypeConverter().mandatoryConvertTo(left.getClass(), exchange, val);
} catch (NoTypeConversionAvailableException e) {
throw RuntimeCamelException.wrapRuntimeCamelException(e);
}
// and return the result
- return exchange.getContext().getTypeConverter().convertTo(type, left);
+ return camelContext.getTypeConverter().convertTo(type, left);
}
// cannot convert the expression as a number
Exception cause = new CamelExchangeException("Cannot evaluate " + leftExp + " as a number", exchange);
@@ -108,7 +109,7 @@ public class UnaryExpression extends BaseSimpleNode {
};
}
- private Expression createDecExpression(final Expression leftExp) {
+ private Expression createDecExpression(CamelContext camelContext, final Expression leftExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -120,13 +121,13 @@ public class UnaryExpression extends BaseSimpleNode {
// convert value back to same type as input as we want to preserve type
Object left = leftExp.evaluate(exchange, Object.class);
try {
- left = exchange.getContext().getTypeConverter().mandatoryConvertTo(left.getClass(), exchange, val);
+ left = camelContext.getTypeConverter().mandatoryConvertTo(left.getClass(), exchange, val);
} catch (NoTypeConversionAvailableException e) {
throw RuntimeCamelException.wrapRuntimeCamelException(e);
}
// and return the result
- return exchange.getContext().getTypeConverter().convertTo(type, left);
+ return camelContext.getTypeConverter().convertTo(type, left);
}
// cannot convert the expression as a number
Exception cause = new CamelExchangeException("Cannot evaluate " + leftExp + " as a number", exchange);
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleBackwardsCompatibleTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleBackwardsCompatibleTest.java
index fae4e5b..97a4a1c 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleBackwardsCompatibleTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleBackwardsCompatibleTest.java
@@ -55,7 +55,7 @@ public class SimpleBackwardsCompatibleTest extends LanguageTestSupport {
exchange.getIn().setHeader("high", true);
exchange.getIn().setHeader("foo", 123);
- SimplePredicateParser parser = new SimplePredicateParser("${header.high} == true && ${header.foo} == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == true && ${header.foo} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -67,7 +67,7 @@ public class SimpleBackwardsCompatibleTest extends LanguageTestSupport {
exchange.getIn().setHeader("high", true);
exchange.getIn().setHeader("foo", 123);
- SimplePredicateParser parser = new SimplePredicateParser("${header.high} == false || ${header.foo} == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == false || ${header.foo} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionInvalidTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionInvalidTest.java
index ae6906c..fdcd6c0 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionInvalidTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionInvalidTest.java
@@ -30,7 +30,7 @@ public class SimpleParserExpressionInvalidTest extends ExchangeTestSupport {
@Test
public void testSimpleUnbalanceFunction() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("${body is a nice day", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${body is a nice day", true, null);
try {
parser.parseExpression();
fail("Should thrown exception");
@@ -41,7 +41,7 @@ public class SimpleParserExpressionInvalidTest extends ExchangeTestSupport {
@Test
public void testSimpleNestedUnbalanceFunction() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("${body${foo}", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${body${foo}", true, null);
try {
parser.parseExpression();
fail("Should thrown exception");
@@ -52,7 +52,7 @@ public class SimpleParserExpressionInvalidTest extends ExchangeTestSupport {
@Test
public void testSimpleUnknownFunction() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("Hello ${foo} how are you?", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "Hello ${foo} how are you?", true, null);
try {
parser.parseExpression();
fail("Should thrown exception");
@@ -63,7 +63,7 @@ public class SimpleParserExpressionInvalidTest extends ExchangeTestSupport {
@Test
public void testSimpleNestedUnknownFunction() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("Hello ${bodyAs(${foo})} how are you?", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "Hello ${bodyAs(${foo})} how are you?", true, null);
try {
// nested functions can only be syntax evaluated when evaluating an
// exchange at runtime
@@ -77,7 +77,7 @@ public class SimpleParserExpressionInvalidTest extends ExchangeTestSupport {
@Test
public void testNoEndFunction() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("Hello ${body", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "Hello ${body", true, null);
try {
parser.parseExpression();
fail("Should thrown exception");
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionTest.java
index 5a07161..31d5107 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionTest.java
@@ -30,7 +30,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleParserEol() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("Hello", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "Hello", true, null);
Expression exp = parser.parseExpression();
assertEquals("Hello", exp.evaluate(exchange, String.class));
@@ -38,7 +38,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleSingleQuote() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("'Hello'", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "'Hello'", true, null);
Expression exp = parser.parseExpression();
assertEquals("'Hello'", exp.evaluate(exchange, String.class));
@@ -46,7 +46,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleStringList() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("\"Hello\" \"World\"", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "\"Hello\" \"World\"", true, null);
Expression exp = parser.parseExpression();
assertEquals("\"Hello\" \"World\"", exp.evaluate(exchange, String.class));
@@ -55,7 +55,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleSingleQuoteWithFunction() throws Exception {
exchange.getIn().setBody("World");
- SimpleExpressionParser parser = new SimpleExpressionParser("'Hello ${body} how are you?'", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "'Hello ${body} how are you?'", true, null);
Expression exp = parser.parseExpression();
assertEquals("'Hello World how are you?'", exp.evaluate(exchange, String.class));
@@ -64,7 +64,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleSingleQuoteWithFunctionBodyAs() throws Exception {
exchange.getIn().setBody("World");
- SimpleExpressionParser parser = new SimpleExpressionParser("'Hello ${bodyAs(String)} how are you?'", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "'Hello ${bodyAs(String)} how are you?'", true, null);
Expression exp = parser.parseExpression();
assertEquals("'Hello World how are you?'", exp.evaluate(exchange, String.class));
@@ -72,7 +72,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleSingleQuoteEol() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("'Hello' World", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "'Hello' World", true, null);
Expression exp = parser.parseExpression();
assertEquals("'Hello' World", exp.evaluate(exchange, String.class));
@@ -81,7 +81,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleFunction() throws Exception {
exchange.getIn().setBody("World");
- SimpleExpressionParser parser = new SimpleExpressionParser("${body}", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${body}", true, null);
Expression exp = parser.parseExpression();
assertEquals("World", exp.evaluate(exchange, String.class));
@@ -89,7 +89,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleSingleQuoteDollar() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("Pay 200$ today", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "Pay 200$ today", true, null);
Expression exp = parser.parseExpression();
assertEquals("Pay 200$ today", exp.evaluate(exchange, String.class));
@@ -97,7 +97,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleSingleQuoteDollarEnd() throws Exception {
- SimpleExpressionParser parser = new SimpleExpressionParser("Pay 200$", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "Pay 200$", true, null);
Expression exp = parser.parseExpression();
assertEquals("Pay 200$", exp.evaluate(exchange, String.class));
@@ -106,7 +106,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleUnaryInc() throws Exception {
exchange.getIn().setBody("122");
- SimpleExpressionParser parser = new SimpleExpressionParser("${body}++", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${body}++", true, null);
Expression exp = parser.parseExpression();
assertEquals("123", exp.evaluate(exchange, String.class));
@@ -115,7 +115,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleUnaryDec() throws Exception {
exchange.getIn().setBody("122");
- SimpleExpressionParser parser = new SimpleExpressionParser("${body}--", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${body}--", true, null);
Expression exp = parser.parseExpression();
assertEquals("121", exp.evaluate(exchange, String.class));
@@ -124,7 +124,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleUnaryIncInt() throws Exception {
exchange.getIn().setBody(122);
- SimpleExpressionParser parser = new SimpleExpressionParser("${body}++", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${body}++", true, null);
Expression exp = parser.parseExpression();
assertEquals(Integer.valueOf(123), exp.evaluate(exchange, Integer.class));
@@ -133,7 +133,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleUnaryDecInt() throws Exception {
exchange.getIn().setBody(122);
- SimpleExpressionParser parser = new SimpleExpressionParser("${body}--", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${body}--", true, null);
Expression exp = parser.parseExpression();
assertEquals(Integer.valueOf(121), exp.evaluate(exchange, Integer.class));
@@ -143,7 +143,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
public void testHeaderNestedFunction() throws Exception {
exchange.getIn().setBody("foo");
exchange.getIn().setHeader("foo", "abc");
- SimpleExpressionParser parser = new SimpleExpressionParser("${header.${body}}", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${header.${body}}", true, null);
Expression exp = parser.parseExpression();
Object obj = exp.evaluate(exchange, Object.class);
@@ -155,7 +155,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
public void testBodyAsNestedFunction() throws Exception {
exchange.getIn().setBody("123");
exchange.getIn().setHeader("foo", "Integer");
- SimpleExpressionParser parser = new SimpleExpressionParser("${bodyAs(${header.foo})}", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${bodyAs(${header.foo})}", true, null);
Expression exp = parser.parseExpression();
Object obj = exp.evaluate(exchange, Object.class);
@@ -171,7 +171,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
exchange.getIn().setHeader("bar", "e");
exchange.getIn().setHeader("baz", "ger");
SimpleExpressionParser parser
- = new SimpleExpressionParser("${bodyAs(${header.foo}${header.bar}${header.baz})}", true, null);
+ = new SimpleExpressionParser(context, "${bodyAs(${header.foo}${header.bar}${header.baz})}", true, null);
Expression exp = parser.parseExpression();
Object obj = exp.evaluate(exchange, Object.class);
@@ -185,7 +185,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
exchange.getIn().setBody("123");
exchange.getIn().setHeader("foo", "Integer");
exchange.getIn().setHeader("bar", "foo");
- SimpleExpressionParser parser = new SimpleExpressionParser("${bodyAs(${header.${header.bar}})}", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${bodyAs(${header.${header.bar}})}", true, null);
Expression exp = parser.parseExpression();
Object obj = exp.evaluate(exchange, Object.class);
@@ -202,11 +202,11 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
exchange.getIn().setBody(map);
- SimpleExpressionParser parser = new SimpleExpressionParser("${body[foo]}", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "${body[foo]}", true, null);
Expression exp = parser.parseExpression();
assertEquals("123", exp.evaluate(exchange, Object.class));
- parser = new SimpleExpressionParser("${body['foo bar']}", true, null);
+ parser = new SimpleExpressionParser(context, "${body['foo bar']}", true, null);
exp = parser.parseExpression();
assertEquals("456", exp.evaluate(exchange, Object.class));
}
@@ -216,7 +216,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
exchange.getIn().setHeader("JMSMessageID", "JMSMessageID-123");
exchange.getIn().setBody("THE MSG ID ${header.JMSMessageID} isA --");
- SimpleExpressionParser parser = new SimpleExpressionParser("THE MSG ID ${header.JMSMessageID} isA --", true, null);
+ SimpleExpressionParser parser = new SimpleExpressionParser(context, "THE MSG ID ${header.JMSMessageID} isA --", true, null);
Expression exp = parser.parseExpression();
assertEquals("THE MSG ID JMSMessageID-123 isA --", exp.evaluate(exchange, String.class));
@@ -228,7 +228,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
exchange.getIn().setBody("------------THE MSG ID ${header.JMSMessageID}------------");
SimpleExpressionParser parser
- = new SimpleExpressionParser("------------THE MSG ID ${header.JMSMessageID}------------", true, null);
+ = new SimpleExpressionParser(context, "------------THE MSG ID ${header.JMSMessageID}------------", true, null);
Expression exp = parser.parseExpression();
assertEquals("------------THE MSG ID JMSMessageID-123------------", exp.evaluate(exchange, String.class));
@@ -240,7 +240,7 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
exchange.getIn().setBody("------------ THE MSG ID ${header.JMSMessageID} ------------");
SimpleExpressionParser parser
- = new SimpleExpressionParser("------------ THE MSG ID ${header.JMSMessageID} ------------", true, null);
+ = new SimpleExpressionParser(context, "------------ THE MSG ID ${header.JMSMessageID} ------------", true, null);
Expression exp = parser.parseExpression();
assertEquals("------------ THE MSG ID JMSMessageID-123 ------------", exp.evaluate(exchange, String.class));
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateInvalidTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateInvalidTest.java
index 29b8b94..56938c7 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateInvalidTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateInvalidTest.java
@@ -33,7 +33,7 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
exchange.getIn().setBody("Hello");
exchange.getIn().setHeader("high", true);
- SimplePredicateParser parser = new SimplePredicateParser("${header.high} == abc", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == abc", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
@@ -47,7 +47,7 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
exchange.getIn().setBody("Hello");
exchange.getIn().setHeader("high", true);
- SimplePredicateParser parser = new SimplePredicateParser("${header.high} = true", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} = true", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
@@ -60,7 +60,7 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
public void testSimpleUnevenSingleQuote() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser("${body} == 'foo", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == 'foo", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
@@ -73,7 +73,7 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
public void testSimpleUnevenDoubleQuote() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser("${body} == \"foo", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == \"foo", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
@@ -86,7 +86,7 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
public void testSimpleTwoAnd() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser("${body} == 'foo' && && ${header} == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == 'foo' && && ${header} == 123", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
@@ -99,7 +99,7 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
public void testSimpleTwoOr() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser("${body} == 'foo' || || ${header} == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == 'foo' || || ${header} == 123", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
@@ -112,7 +112,7 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
public void testSimpleTwoEq() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser("${body} == == 'foo'", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == == 'foo'", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateTest.java
index d43a925..7fcb6f3 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateTest.java
@@ -38,11 +38,11 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
public void testSimpleBooleanValue() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser("true", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "true", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange));
- parser = new SimplePredicateParser("false", true, null);
+ parser = new SimplePredicateParser(context, "false", true, null);
pre = parser.parsePredicate();
assertFalse(pre.matches(exchange));
}
@@ -51,7 +51,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
public void testSimpleEq() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser("${body} == 'foo'", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == 'foo'", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange));
@@ -61,7 +61,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
public void testSimpleEqNumeric() throws Exception {
exchange.getIn().setBody(123);
- SimplePredicateParser parser = new SimplePredicateParser("${body} == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -72,7 +72,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setBody(122);
exchange.getIn().setHeader("val", 122);
- SimplePredicateParser parser = new SimplePredicateParser("${body} == ${header.val}", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == ${header.val}", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -82,7 +82,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
public void testSimpleEqFunctionNumeric() throws Exception {
exchange.getIn().setBody(122);
- SimplePredicateParser parser = new SimplePredicateParser("${body} == 122", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == 122", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -92,7 +92,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
public void testSimpleGtFunctionNumeric() throws Exception {
exchange.getIn().setBody(122);
- SimplePredicateParser parser = new SimplePredicateParser("${body} > 120", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} > 120", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -102,7 +102,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
public void testSimpleUnaryInc() throws Exception {
exchange.getIn().setBody(122);
- SimplePredicateParser parser = new SimplePredicateParser("${body}++ == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body}++ == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -112,7 +112,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
public void testSimpleUnaryDec() throws Exception {
exchange.getIn().setBody(122);
- SimplePredicateParser parser = new SimplePredicateParser("${body}-- == 121", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body}-- == 121", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -123,7 +123,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setBody("Hello");
exchange.getIn().setHeader("high", true);
- SimplePredicateParser parser = new SimplePredicateParser("${header.high} == true", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == true", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -134,7 +134,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setBody("Hello");
exchange.getIn().setHeader("high", true);
- SimplePredicateParser parser = new SimplePredicateParser("${header.high} == true", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == true", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -146,7 +146,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setHeader("high", true);
exchange.getIn().setHeader("foo", 123);
- SimplePredicateParser parser = new SimplePredicateParser("${header.high} == true && ${header.foo} == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == true && ${header.foo} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -158,7 +158,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setHeader("high", true);
exchange.getIn().setHeader("foo", 123);
- SimplePredicateParser parser = new SimplePredicateParser("${header.high} == false || ${header.foo} == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == false || ${header.foo} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -171,7 +171,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setHeader("foo", 123);
exchange.getIn().setHeader("bar", "beer");
- SimplePredicateParser parser = new SimplePredicateParser(
+ SimplePredicateParser parser = new SimplePredicateParser(context,
"${header.high} == true && ${header.foo} == 123 && ${header.bar} == 'beer'", true, null);
Predicate pre = parser.parsePredicate();
@@ -191,7 +191,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
}
}
- SimplePredicateParser parser = new SimplePredicateParser(sb.toString(), true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, sb.toString(), true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -210,7 +210,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
}
sb.append(" || ${body} == 'Hello'");
- SimplePredicateParser parser = new SimplePredicateParser(sb.toString(), true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, sb.toString(), true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -220,7 +220,7 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
public void testSimpleExpressionPredicate() throws Exception {
exchange.getIn().setBody("Hello");
exchange.getIn().setHeader("number", "1234");
- SimplePredicateParser parser = new SimplePredicateParser("${in.header.number} regex '\\d{4}'", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${in.header.number} regex '\\d{4}'", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
}
@@ -233,21 +233,21 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setBody(map);
- SimplePredicateParser parser = new SimplePredicateParser("${body[foo]} == 123", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body[foo]} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
- parser = new SimplePredicateParser("${body['foo bar']} == 456", true, null);
+ parser = new SimplePredicateParser(context, "${body['foo bar']} == 456", true, null);
pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
// the predicate has whitespace in the function
- parser = new SimplePredicateParser("${body[foo bar]} == 456", true, null);
+ parser = new SimplePredicateParser(context, "${body[foo bar]} == 456", true, null);
pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
// no header with that name
- parser = new SimplePredicateParser("${body[unknown]} == 456", true, null);
+ parser = new SimplePredicateParser(context, "${body[unknown]} == 456", true, null);
pre = parser.parsePredicate();
assertFalse(pre.matches(exchange), "Should not match");
}
@@ -272,22 +272,22 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
map.put("key3", "none");
exchange.getIn().setBody(map);
- SimplePredicateParser parser = new SimplePredicateParser("${body[key]} in ${ref:myList}", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body[key]} in ${ref:myList}", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
- parser = new SimplePredicateParser("${body[key2]} in ${ref:myList}", true, null);
+ parser = new SimplePredicateParser(context, "${body[key2]} in ${ref:myList}", true, null);
pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
- parser = new SimplePredicateParser("${body[key3]} in ${ref:myList}", true, null);
+ parser = new SimplePredicateParser(context, "${body[key3]} in ${ref:myList}", true, null);
pre = parser.parsePredicate();
assertFalse(pre.matches(exchange), "Should not match");
}
@Test
public void testSimpleInEmpty() throws Exception {
- SimplePredicateParser parser = new SimplePredicateParser("${body} in ',,gold,silver'", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} in ',,gold,silver'", true, null);
Predicate pre = parser.parsePredicate();
exchange.getIn().setBody("gold");
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserRegexpPredicateTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserRegexpPredicateTest.java
index 1376afb..35ec401 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserRegexpPredicateTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserRegexpPredicateTest.java
@@ -32,7 +32,7 @@ public class SimpleParserRegexpPredicateTest extends ExchangeTestSupport {
public void testSimpleRegexp() throws Exception {
exchange.getIn().setBody("12.34.5678");
- SimplePredicateParser parser = new SimplePredicateParser("${body} regex '^\\d{2}\\.\\d{2}\\.\\d{4}$'", true, null);
+ SimplePredicateParser parser = new SimplePredicateParser(context, "${body} regex '^\\d{2}\\.\\d{2}\\.\\d{4}$'", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange));
[camel] 02/04: CAMEL-15605: Languages should be singleton for
better performance.
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit d8da8cc17a6a2f979effc18195fd86becd77d60b
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Fri Oct 2 11:26:34 2020 +0200
CAMEL-15605: Languages should be singleton for better performance.
---
docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_6.adoc | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_6.adoc b/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_6.adoc
index 594799d..22a10e7 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_6.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-3x-upgrade-guide-3_6.adoc
@@ -41,6 +41,12 @@ The components affected are:
- camel-twilio
- camel-zendesk
+=== Languages
+
+All the out of the box supported languages (simple, bean, groovy, jsonpath, xpath etc.) have been optmized to be _singleton_
+which improves performance for concurrent processing that uses those languages that would be resolved on each use.
+Now the languages is resolved once during startup or first usage.
+
=== Customizers
Customizers, which are objects used to configure some of the Camel services such as component, language and data formats, that were previously limited to Camel Spring Boot, are now consistently used across runtimes.
[camel] 03/04: CAMEL-15606: camel-core - Simple with bean function
should resolve language once
Posted by da...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit eedd9a81941c72ea8428cac70c5fedd72c8e7d49
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Fri Oct 2 11:27:03 2020 +0200
CAMEL-15606: camel-core - Simple with bean function should resolve language once
---
.../camel/impl/engine/AbstractCamelContext.java | 1 -
.../camel/language/simple/SimpleLanguage.java | 6 ++++--
.../language/simple/SimplePredicateParser.java | 3 ++-
.../camel/language/simple/ast/BinaryExpression.java | 21 ++++++++++++++-------
.../simple/ast/SimpleFunctionExpression.java | 10 +++++-----
.../camel/language/simple/ast/SimpleNode.java | 6 +++---
.../simple/SimpleBackwardsCompatibleTest.java | 6 ++++--
.../language/simple/SimpleParserExpressionTest.java | 9 ++++++---
.../simple/SimpleParserPredicateInvalidTest.java | 6 ++++--
.../language/simple/SimpleParserPredicateTest.java | 9 ++++++---
.../simple/SimpleParserRegexpPredicateTest.java | 3 ++-
11 files changed, 50 insertions(+), 30 deletions(-)
diff --git a/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java b/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index 8e4e940..93c92b5 100644
--- a/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++ b/core/camel-base/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -1638,7 +1638,6 @@ public abstract class AbstractCamelContext extends BaseService
@Override
public Language resolveLanguage(String language) {
LOG.debug("Resolving language: {}", language);
- System.out.println("Resolving language: " + language);
Language answer;
synchronized (languages) {
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
index 2f1e16d..b7e05ce 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleLanguage.java
@@ -104,7 +104,8 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
expression = loadResource(expression);
- SimplePredicateParser parser = new SimplePredicateParser(getCamelContext(), expression, allowEscape, cacheExpression);
+ SimplePredicateParser parser
+ = new SimplePredicateParser(getCamelContext(), expression, allowEscape, cacheExpression);
answer = parser.parsePredicate();
if (cachePredicate != null && answer != null) {
@@ -124,7 +125,8 @@ public class SimpleLanguage extends LanguageSupport implements StaticService {
expression = loadResource(expression);
- SimpleExpressionParser parser = new SimpleExpressionParser(getCamelContext(), expression, allowEscape, cacheExpression);
+ SimpleExpressionParser parser
+ = new SimpleExpressionParser(getCamelContext(), expression, allowEscape, cacheExpression);
answer = parser.parseExpression();
if (cacheExpression != null && answer != null) {
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimplePredicateParser.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimplePredicateParser.java
index 392953b..6cc77d3 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimplePredicateParser.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimplePredicateParser.java
@@ -63,7 +63,8 @@ public class SimplePredicateParser extends BaseSimpleParser {
// use caches to avoid re-parsing the same expressions over and over again
private Map<String, Expression> cacheExpression;
- public SimplePredicateParser(CamelContext camelContext, String expression, boolean allowEscape, Map<String, Expression> cacheExpression) {
+ public SimplePredicateParser(CamelContext camelContext, String expression, boolean allowEscape,
+ Map<String, Expression> cacheExpression) {
super(camelContext, expression, allowEscape);
this.cacheExpression = cacheExpression;
}
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BinaryExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BinaryExpression.java
index f0fbaeb..a995946 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BinaryExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/BinaryExpression.java
@@ -86,7 +86,8 @@ public class BinaryExpression extends BaseSimpleNode {
} else if (operator == BinaryOperatorType.GT) {
return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isGreaterThan(leftExp, rightExp));
} else if (operator == BinaryOperatorType.GTE) {
- return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isGreaterThanOrEqualTo(leftExp, rightExp));
+ return createExpression(camelContext, leftExp, rightExp,
+ PredicateBuilder.isGreaterThanOrEqualTo(leftExp, rightExp));
} else if (operator == BinaryOperatorType.LT) {
return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.isLessThan(leftExp, rightExp));
} else if (operator == BinaryOperatorType.LTE) {
@@ -99,7 +100,8 @@ public class BinaryExpression extends BaseSimpleNode {
} else if (operator == BinaryOperatorType.CONTAINS) {
return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.contains(leftExp, rightExp));
} else if (operator == BinaryOperatorType.NOT_CONTAINS) {
- return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.not(PredicateBuilder.contains(leftExp, rightExp)));
+ return createExpression(camelContext, leftExp, rightExp,
+ PredicateBuilder.not(PredicateBuilder.contains(leftExp, rightExp)));
} else if (operator == BinaryOperatorType.CONTAINS_IGNORECASE) {
return createExpression(camelContext, leftExp, rightExp, PredicateBuilder.containsIgnoreCase(leftExp, rightExp));
} else if (operator == BinaryOperatorType.NOT_CONTAINS_IGNORECASE) {
@@ -122,7 +124,8 @@ public class BinaryExpression extends BaseSimpleNode {
throw new SimpleParserException("Unknown binary operator " + operator, token.getIndex());
}
- private Expression createIsExpression(final CamelContext camelContext, final String expression, final Expression leftExp, final Expression rightExp) {
+ private Expression createIsExpression(
+ final CamelContext camelContext, final String expression, final Expression leftExp, final Expression rightExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -156,7 +159,8 @@ public class BinaryExpression extends BaseSimpleNode {
};
}
- private Expression createRegexExpression(final CamelContext camelContext, final Expression leftExp, final Expression rightExp) {
+ private Expression createRegexExpression(
+ final CamelContext camelContext, final Expression leftExp, final Expression rightExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -176,7 +180,8 @@ public class BinaryExpression extends BaseSimpleNode {
};
}
- private Expression createInExpression(final CamelContext camelContext, final Expression leftExp, final Expression rightExp) {
+ private Expression createInExpression(
+ final CamelContext camelContext, final Expression leftExp, final Expression rightExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -205,7 +210,8 @@ public class BinaryExpression extends BaseSimpleNode {
};
}
- private Expression createRangeExpression(final CamelContext camelContext, final String expression, final Expression leftExp, final Expression rightExp) {
+ private Expression createRangeExpression(
+ final CamelContext camelContext, final String expression, final Expression leftExp, final Expression rightExp) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
@@ -241,7 +247,8 @@ public class BinaryExpression extends BaseSimpleNode {
};
}
- private Expression createExpression(final CamelContext camelContext, final Expression left, final Expression right, final Predicate predicate) {
+ private Expression createExpression(
+ final CamelContext camelContext, final Expression left, final Expression right, final Predicate predicate) {
return new Expression() {
@Override
public <T> T evaluate(Exchange exchange, Class<T> type) {
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
index 5f848e3..12ddf6c 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleFunctionExpression.java
@@ -63,11 +63,11 @@ public class SimpleFunctionExpression extends LiteralExpression {
/**
* Creates a Camel {@link Expression} based on this model.
*
- * @param expression not in use
- * @param strict whether to throw exception if the expression
- * was not a function, otherwise <tt>null</tt>
- * is returned
- * @return the created {@link Expression}
+ * @param expression not in use
+ * @param strict whether to throw exception if the expression
+ * was not a function, otherwise <tt>null</tt>
+ * is returned
+ * @return the created {@link Expression}
* @throws org.apache.camel.language.simple.types.SimpleParserException should be thrown if error parsing the model
*/
public Expression createExpression(CamelContext camelContext, String expression, boolean strict) {
diff --git a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleNode.java b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleNode.java
index afe5921..1bef48f 100644
--- a/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleNode.java
+++ b/core/camel-core-languages/src/main/java/org/apache/camel/language/simple/ast/SimpleNode.java
@@ -36,9 +36,9 @@ public interface SimpleNode {
/**
* Creates a Camel {@link Expression} based on this model.
*
- * @param camelContext the camel context
- * @param expression the input string
- * @return the created {@link Expression}
+ * @param camelContext the camel context
+ * @param expression the input string
+ * @return the created {@link Expression}
* @throws org.apache.camel.language.simple.types.SimpleParserException should be thrown if error parsing the model
*/
Expression createExpression(CamelContext camelContext, String expression) throws SimpleParserException;
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleBackwardsCompatibleTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleBackwardsCompatibleTest.java
index 97a4a1c..7364925 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleBackwardsCompatibleTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleBackwardsCompatibleTest.java
@@ -55,7 +55,8 @@ public class SimpleBackwardsCompatibleTest extends LanguageTestSupport {
exchange.getIn().setHeader("high", true);
exchange.getIn().setHeader("foo", 123);
- SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == true && ${header.foo} == 123", true, null);
+ SimplePredicateParser parser
+ = new SimplePredicateParser(context, "${header.high} == true && ${header.foo} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -67,7 +68,8 @@ public class SimpleBackwardsCompatibleTest extends LanguageTestSupport {
exchange.getIn().setHeader("high", true);
exchange.getIn().setHeader("foo", 123);
- SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == false || ${header.foo} == 123", true, null);
+ SimplePredicateParser parser
+ = new SimplePredicateParser(context, "${header.high} == false || ${header.foo} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionTest.java
index 31d5107..cf8e019 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserExpressionTest.java
@@ -64,7 +64,8 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
@Test
public void testSimpleSingleQuoteWithFunctionBodyAs() throws Exception {
exchange.getIn().setBody("World");
- SimpleExpressionParser parser = new SimpleExpressionParser(context, "'Hello ${bodyAs(String)} how are you?'", true, null);
+ SimpleExpressionParser parser
+ = new SimpleExpressionParser(context, "'Hello ${bodyAs(String)} how are you?'", true, null);
Expression exp = parser.parseExpression();
assertEquals("'Hello World how are you?'", exp.evaluate(exchange, String.class));
@@ -216,7 +217,8 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
exchange.getIn().setHeader("JMSMessageID", "JMSMessageID-123");
exchange.getIn().setBody("THE MSG ID ${header.JMSMessageID} isA --");
- SimpleExpressionParser parser = new SimpleExpressionParser(context, "THE MSG ID ${header.JMSMessageID} isA --", true, null);
+ SimpleExpressionParser parser
+ = new SimpleExpressionParser(context, "THE MSG ID ${header.JMSMessageID} isA --", true, null);
Expression exp = parser.parseExpression();
assertEquals("THE MSG ID JMSMessageID-123 isA --", exp.evaluate(exchange, String.class));
@@ -240,7 +242,8 @@ public class SimpleParserExpressionTest extends ExchangeTestSupport {
exchange.getIn().setBody("------------ THE MSG ID ${header.JMSMessageID} ------------");
SimpleExpressionParser parser
- = new SimpleExpressionParser(context, "------------ THE MSG ID ${header.JMSMessageID} ------------", true, null);
+ = new SimpleExpressionParser(
+ context, "------------ THE MSG ID ${header.JMSMessageID} ------------", true, null);
Expression exp = parser.parseExpression();
assertEquals("------------ THE MSG ID JMSMessageID-123 ------------", exp.evaluate(exchange, String.class));
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateInvalidTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateInvalidTest.java
index 56938c7..404ec9f 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateInvalidTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateInvalidTest.java
@@ -86,7 +86,8 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
public void testSimpleTwoAnd() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == 'foo' && && ${header} == 123", true, null);
+ SimplePredicateParser parser
+ = new SimplePredicateParser(context, "${body} == 'foo' && && ${header} == 123", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
@@ -99,7 +100,8 @@ public class SimpleParserPredicateInvalidTest extends ExchangeTestSupport {
public void testSimpleTwoOr() throws Exception {
exchange.getIn().setBody("foo");
- SimplePredicateParser parser = new SimplePredicateParser(context, "${body} == 'foo' || || ${header} == 123", true, null);
+ SimplePredicateParser parser
+ = new SimplePredicateParser(context, "${body} == 'foo' || || ${header} == 123", true, null);
try {
parser.parsePredicate();
fail("Should thrown exception");
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateTest.java
index 7fcb6f3..1068715 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserPredicateTest.java
@@ -146,7 +146,8 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setHeader("high", true);
exchange.getIn().setHeader("foo", 123);
- SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == true && ${header.foo} == 123", true, null);
+ SimplePredicateParser parser
+ = new SimplePredicateParser(context, "${header.high} == true && ${header.foo} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -158,7 +159,8 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setHeader("high", true);
exchange.getIn().setHeader("foo", 123);
- SimplePredicateParser parser = new SimplePredicateParser(context, "${header.high} == false || ${header.foo} == 123", true, null);
+ SimplePredicateParser parser
+ = new SimplePredicateParser(context, "${header.high} == false || ${header.foo} == 123", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange), "Should match");
@@ -171,7 +173,8 @@ public class SimpleParserPredicateTest extends ExchangeTestSupport {
exchange.getIn().setHeader("foo", 123);
exchange.getIn().setHeader("bar", "beer");
- SimplePredicateParser parser = new SimplePredicateParser(context,
+ SimplePredicateParser parser = new SimplePredicateParser(
+ context,
"${header.high} == true && ${header.foo} == 123 && ${header.bar} == 'beer'", true, null);
Predicate pre = parser.parsePredicate();
diff --git a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserRegexpPredicateTest.java b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserRegexpPredicateTest.java
index 35ec401..e954f8e 100644
--- a/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserRegexpPredicateTest.java
+++ b/core/camel-core/src/test/java/org/apache/camel/language/simple/SimpleParserRegexpPredicateTest.java
@@ -32,7 +32,8 @@ public class SimpleParserRegexpPredicateTest extends ExchangeTestSupport {
public void testSimpleRegexp() throws Exception {
exchange.getIn().setBody("12.34.5678");
- SimplePredicateParser parser = new SimplePredicateParser(context, "${body} regex '^\\d{2}\\.\\d{2}\\.\\d{4}$'", true, null);
+ SimplePredicateParser parser
+ = new SimplePredicateParser(context, "${body} regex '^\\d{2}\\.\\d{2}\\.\\d{4}$'", true, null);
Predicate pre = parser.parsePredicate();
assertTrue(pre.matches(exchange));