camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject svn commit: r988647 - in /camel/trunk/camel-core/src: main/java/org/apache/camel/language/simple/ test/java/org/apache/camel/component/file/ test/java/org/apache/camel/language/ test/resources/
Date Tue, 24 Aug 2010 18:18:41 GMT
Author: davsclaus
Date: Tue Aug 24 18:18:41 2010
New Revision: 988647

URL: http://svn.apache.org/viewvc?rev=988647&view=rev
Log:
CAMEL-3075: Simple language now supports using unlimited and,or operators.

Modified:
    camel/trunk/camel-core/src/main/java/org/apache/camel/language/simple/SimpleLanguageSupport.java
    camel/trunk/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerPollStrategyTest.java
    camel/trunk/camel-core/src/test/java/org/apache/camel/language/SimpleOperatorTest.java
    camel/trunk/camel-core/src/test/resources/log4j.properties

Modified: camel/trunk/camel-core/src/main/java/org/apache/camel/language/simple/SimpleLanguageSupport.java
URL: http://svn.apache.org/viewvc/camel/trunk/camel-core/src/main/java/org/apache/camel/language/simple/SimpleLanguageSupport.java?rev=988647&r1=988646&r2=988647&view=diff
==============================================================================
--- camel/trunk/camel-core/src/main/java/org/apache/camel/language/simple/SimpleLanguageSupport.java
(original)
+++ camel/trunk/camel-core/src/main/java/org/apache/camel/language/simple/SimpleLanguageSupport.java
Tue Aug 24 18:18:41 2010
@@ -30,6 +30,7 @@ import org.apache.camel.builder.Expressi
 import org.apache.camel.builder.PredicateBuilder;
 import org.apache.camel.builder.ValueBuilder;
 import org.apache.camel.spi.Language;
+import org.apache.camel.util.KeyValueHolder;
 import org.apache.camel.util.ObjectHelper;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -41,27 +42,49 @@ import static org.apache.camel.language.
 public abstract class SimpleLanguageSupport implements Language, IsSingleton {
 
     // this is a regex for a given group in a simple expression that uses operators
-    protected static final String GROUP_PATTERN =
+    protected static final String OPERATOR_REGEX =
         "\\$\\{(\\S+)\\}\\s+(==|>|>=|<|<=|!=|contains|not contains|regex|not
regex|in|not in|is|not is|range|not range)\\s+('.*?'|\\S+)";
 
     // this is the operator reg ex pattern used to match if a given expression is operator
based or not
-    protected static final Pattern PATTERN = Pattern.compile("^(" + GROUP_PATTERN + ")(\\s+(and|or)\\s+("
+ GROUP_PATTERN + "))?$");
+    protected static final Pattern OPERATOR_PATTERN = Pattern.compile(OPERATOR_REGEX);
+
+    // two specialized pattern for matching/finding multiple expressions combined using multiple
and|or operators
+    protected static final Pattern ANDOR_PATTERN = Pattern.compile("\\s+(and|or)\\s+" + OPERATOR_REGEX);
+    protected static final Pattern START_ANDOR_PATTERN = Pattern.compile("^" + OPERATOR_REGEX
+ "\\s+(and|or)\\s+.*$");
 
     // this is special for the range operator where you define the range as from..to (where
from and to are numbers)
     protected static final Pattern RANGE_PATTERN = Pattern.compile("^(\\d+)(\\.\\.)(\\d+)$");
     protected final Log log = LogFactory.getLog(getClass());
 
+    /**
+     * A holder class to hold an operator and the expression.
+     * <p/>
+     * This is used for expression with multiple expressions grouped using and/or operators
+     */
+    private final class ExpressionGroup extends KeyValueHolder<SimpleLanguageOperator,
Expression> {
+
+        public ExpressionGroup(SimpleLanguageOperator key, Expression value) {
+            super(key, value);
+        }
+
+        @Override
+        public String toString() {
+            return getKey() + " " + getValue();
+        }
+    }
+
     public Predicate createPredicate(String expression) {
         return PredicateBuilder.toPredicate(createExpression(expression));
     }
 
     public Expression createExpression(String expression) {
-        Matcher matcher = PATTERN.matcher(expression);
-        if (matcher.matches()) {
+        Matcher matcher = OPERATOR_PATTERN.matcher(expression);
+        Matcher startMatcher = START_ANDOR_PATTERN.matcher(expression);
+        if (matcher.matches() || startMatcher.matches()) {
             if (log.isDebugEnabled()) {
-                log.debug("Expression is evaluated as simple expression with operator: "
+ expression);
+                log.debug("Expression is evaluated as simple (with operator) expression:
" + expression);
             }
-            return createOperatorExpression(matcher, expression);
+            return createOperatorExpression(matcher, startMatcher, expression);
         } else if (expression.indexOf("${") >= 0) {
             if (log.isDebugEnabled()) {
                 log.debug("Expression is evaluated as simple (strict) expression: " + expression);
@@ -75,54 +98,80 @@ public abstract class SimpleLanguageSupp
         }
     }
 
-    private Expression createOperatorExpression(final Matcher matcher, final String expression)
{
-        int groupCount = matcher.groupCount();
+    private Expression createOperatorExpression(Matcher matcher, Matcher startMatcher, String
expression) {
+        Expression answer = null;
 
-        if (log.isTraceEnabled()) {
-            log.trace("Matcher expression: " + expression);
-            log.trace("Matcher group count: " + groupCount);
-            for (int i = 0; i < matcher.groupCount() + 1; i++) {
-                String group = matcher.group(i);
-                if (log.isTraceEnabled()) {
-                    log.trace("Matcher group #" + i + ": " + group);
-                }
-            }
+        if (startMatcher.matches()) {
+            answer = doCreateOperatorExpression(expression, startMatcher.group(1), startMatcher.group(2),
startMatcher.group(3));
+        } else if (matcher.matches()) {
+            answer = doCreateOperatorExpression(expression, matcher.group(1), matcher.group(2),
matcher.group(3));
         }
 
-        // a simple expression with operator can either be a single group or a dual group
-        String operatorText = matcher.group(6);
-        if (operatorText == null) {
-            // single group
-            return doCreateOperatorExpression(expression, matcher.group(2), matcher.group(3),
matcher.group(4));
-        } else {
-            // dual group with an and/or operator between the two groups
-            final Expression first = doCreateOperatorExpression(expression, matcher.group(2),
matcher.group(3), matcher.group(4));
-            final SimpleLanguageOperator operator = asOperator(operatorText);
-            final Expression last = doCreateOperatorExpression(expression, matcher.group(8),
matcher.group(9), matcher.group(10));
-
-            // create a compound predicate to combine the two groups with the operator
-            final Predicate compoundPredicate;
-            if (operator == AND) {
-                compoundPredicate = PredicateBuilder.and(PredicateBuilder.toPredicate(first),
PredicateBuilder.toPredicate(last));
-            } else if (operator == OR) {
-                compoundPredicate = PredicateBuilder.or(PredicateBuilder.toPredicate(first),
PredicateBuilder.toPredicate(last));
-            } else {
+        // append any additional operators
+        answer = appendAdditionalOperatorExpressions(answer, expression);
+
+        return answer;
+    }
+
+    private Expression appendAdditionalOperatorExpressions(final Expression answer, final
String expression) {
+        Matcher matcher = ANDOR_PATTERN.matcher(expression);
+
+        // now go through the and/or and append those sub expressions
+        final List<ExpressionGroup> expressions = new ArrayList<ExpressionGroup>();
+        while (matcher.find()) {
+            dumpMatcher(matcher);
+
+            // we only support AND/OR operator between expression groups
+            final SimpleLanguageOperator operator = asOperator(matcher.group(1));
+            if (operator != AND && operator != OR) {
                 throw new IllegalArgumentException("Syntax error in expression: " + expression
                     + ". Expected operator as either and/or but was: " + operator);
             }
+            final Expression exp = doCreateOperatorExpression(expression, matcher.group(2),
matcher.group(3), matcher.group(4));
+
+            // add this group
+            expressions.add(new ExpressionGroup(operator, exp));
+        }
 
-            // return the expression that evaluates this expression
-            return new Expression() {
-                public <T> T evaluate(Exchange exchange, Class<T> type) {
-                    boolean matches = compoundPredicate.matches(exchange);
-                    return exchange.getContext().getTypeConverter().convertTo(type, matches);
+        // return the expression that evaluates the entire expression with multiple groups
+        return new Expression() {
+            public <T> T evaluate(Exchange exchange, Class<T> type) {
+                boolean matches = PredicateBuilder.toPredicate(answer).matches(exchange);
+                for (ExpressionGroup group : expressions) {
+                    boolean result = PredicateBuilder.toPredicate(group.getValue()).matches(exchange);
+                    if (group.getKey() == AND) {
+                        matches &= result;
+                    } else {
+                        matches |= result;
+                    }
                 }
+                return exchange.getContext().getTypeConverter().convertTo(type, matches);
+            }
 
-                @Override
-                public String toString() {
-                    return first + " " + operator + " " + last;
+            @Override
+            public String toString() {
+                StringBuilder msg = new StringBuilder(answer.toString());
+                for (ExpressionGroup group : expressions) {
+                    msg.append(" ");
+                    msg.append(group.getKey());
+                    msg.append(" ");
+                    msg.append(group.getValue());
                 }
-            };
+                return msg.toString();
+            }
+        };
+    }
+
+    private void dumpMatcher(Matcher matcher) {
+        if (log.isTraceEnabled()) {
+            log.trace("Matcher start: " + matcher.start());
+            log.trace("Matcher end: " + matcher.end());
+            log.trace("Matcher group: " + matcher.group());
+            log.trace("Matcher group count: " + matcher.groupCount());
+            for (int i = 0; i < matcher.groupCount() + 1; i++) {
+                String group = matcher.group(i);
+                log.trace("Matcher group #" + i + ": " + group);
+            }
         }
     }
 

Modified: camel/trunk/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerPollStrategyTest.java
URL: http://svn.apache.org/viewvc/camel/trunk/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerPollStrategyTest.java?rev=988647&r1=988646&r2=988647&view=diff
==============================================================================
--- camel/trunk/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerPollStrategyTest.java
(original)
+++ camel/trunk/camel-core/src/test/java/org/apache/camel/component/file/FileConsumerPollStrategyTest.java
Tue Aug 24 18:18:41 2010
@@ -56,7 +56,7 @@ public class FileConsumerPollStrategyTes
         assertMockEndpointsSatisfied();
 
         // give file consumer a bit time
-        Thread.sleep(1000);
+        Thread.sleep(1500);
 
         assertTrue(event.startsWith("rollbackcommit"));
     }

Modified: camel/trunk/camel-core/src/test/java/org/apache/camel/language/SimpleOperatorTest.java
URL: http://svn.apache.org/viewvc/camel/trunk/camel-core/src/test/java/org/apache/camel/language/SimpleOperatorTest.java?rev=988647&r1=988646&r2=988647&view=diff
==============================================================================
--- camel/trunk/camel-core/src/test/java/org/apache/camel/language/SimpleOperatorTest.java
(original)
+++ camel/trunk/camel-core/src/test/java/org/apache/camel/language/SimpleOperatorTest.java
Tue Aug 24 18:18:41 2010
@@ -47,6 +47,46 @@ public class SimpleOperatorTest extends 
         assertExpression("${in.header.foo} == abc and ${in.header.bar} < 200", true);
     }
 
+    public void testTwoAnd() throws Exception {
+        exchange.getIn().setBody("Hello World");
+        assertExpression("${in.header.foo} == abc and ${in.header.bar} == 123 and ${body}
== 'Hello World'", true);
+        assertExpression("${in.header.foo} == 'abc' and ${in.header.bar} == 123 and ${body}
== 'Hello World'", true);
+        assertExpression("${in.header.foo} == abc and ${in.header.bar} == 123 and ${body}
== 'Bye World'", false);
+        assertExpression("${in.header.foo} == 'abc' and ${in.header.bar} == 123 and ${body}
== 'Bye World'", false);
+    }
+
+    public void testThreeAnd() throws Exception {
+        exchange.getIn().setBody("Hello World");
+        assertExpression("${in.header.foo} == abc and ${in.header.bar} == 123 and ${body}
== 'Hello World' and ${in.header.xx}} == null", true);
+        assertExpression("${in.header.foo} == 'abc' and ${in.header.bar} == 123 and ${body}
== 'Hello World' and ${in.header.xx}} == null", true);
+    }
+
+    public void testTwoOr() throws Exception {
+        exchange.getIn().setBody("Hello World");
+        assertExpression("${in.header.foo} == abc or ${in.header.bar} == 44 or ${body} ==
'Bye World'", true);
+        assertExpression("${in.header.foo} == 'abc' or ${in.header.bar} == 44 or ${body}
== 'Bye World'", true);
+        assertExpression("${in.header.foo} == xxx or ${in.header.bar} == 44 or ${body} ==
'Bye World'", false);
+        assertExpression("${in.header.foo} == 'xxx' or ${in.header.bar} == 44 or ${body}
== 'Bye World'", false);
+        assertExpression("${in.header.foo} == xxx or ${in.header.bar} == 44 or ${body} ==
'Hello World'", true);
+        assertExpression("${in.header.foo} == 'xxx' or ${in.header.bar} == 44 or ${body}
== 'Hello World'", true);
+        assertExpression("${in.header.foo} == xxx or ${in.header.bar} == 123 or ${body} ==
'Bye World'", true);
+        assertExpression("${in.header.foo} == 'xxx' or ${in.header.bar} == 123 or ${body}
== 'Bye World'", true);
+    }
+
+    public void testThreeOr() throws Exception {
+        exchange.getIn().setBody("Hello World");
+        assertExpression("${in.header.foo} == xxx or ${in.header.bar} == 44 or ${body} ==
'Bye Moon' or ${body} contains 'World'", true);
+        assertExpression("${in.header.foo} == 'xxx' or ${in.header.bar} == 44 or ${body}
== 'Bye Moon' or ${body} contains 'World'", true);
+        assertExpression("${in.header.foo} == xxx or ${in.header.bar} == 44 or ${body} ==
'Bye Moon' or ${body} contains 'Moon'", false);
+        assertExpression("${in.header.foo} == 'xxx' or ${in.header.bar} == 44 or ${body}
== 'Bye Moon' or ${body} contains 'Moon'", false);
+        assertExpression("${in.header.foo} == abc or ${in.header.bar} == 44 or ${body} ==
'Bye Moon' or ${body} contains 'Moon'", true);
+        assertExpression("${in.header.foo} == 'abc' or ${in.header.bar} == 44 or ${body}
== 'Bye Moon' or ${body} contains 'Moon'", true);
+        assertExpression("${in.header.foo} == xxx or ${in.header.bar} == 123 or ${body} ==
'Bye Moon' or ${body} contains 'Moon'", true);
+        assertExpression("${in.header.foo} == 'xxx' or ${in.header.bar} == 123 or ${body}
== 'Bye Moon' or ${body} contains 'Moon'", true);
+        assertExpression("${in.header.foo} == xxx or ${in.header.bar} == 44 or ${body} ==
'Hello World' or ${body} contains 'Moon'", true);
+        assertExpression("${in.header.foo} == 'xxx' or ${in.header.bar} == 44 or ${body}
== 'Hello World' or ${body} contains 'Moon'", true);
+    }
+
     public void testAndWithQuotation() throws Exception {
         assertExpression("${in.header.foo} == 'abc' and ${in.header.bar} == '123'", true);
         assertExpression("${in.header.foo} == 'abc' and ${in.header.bar} == '444'", false);

Modified: camel/trunk/camel-core/src/test/resources/log4j.properties
URL: http://svn.apache.org/viewvc/camel/trunk/camel-core/src/test/resources/log4j.properties?rev=988647&r1=988646&r2=988647&view=diff
==============================================================================
--- camel/trunk/camel-core/src/test/resources/log4j.properties (original)
+++ camel/trunk/camel-core/src/test/resources/log4j.properties Tue Aug 24 18:18:41 2010
@@ -26,6 +26,7 @@ log4j.logger.org.apache.camel.impl.Defau
 #log4j.logger.org.apache.camel.impl.converter.DefaultTypeConverter=TRACE
 
 #log4j.logger.org.apache.camel=DEBUG
+#log4j.logger.org.apache.camel.language.simple=TRACE
 #log4j.logger.org.apache.camel.component=TRACE
 #log4j.logger.org.apache.camel.component.seda=TRACE
 #log4j.logger.org.apache.camel.impl.DefaultUnitOfWork=TRACE



Mime
View raw message