CAMEL-22870: camel-core - Add elvis ?: operator to simple language (#20863)

Author: davsclaus

components/camel-csimple-joor/src/test/java/org/apache/camel/language/csimple/joor/OriginalSimpleOperatorTest.java

@@ -34,6 +34,7 @@ public class OriginalSimpleOperatorTest extends LanguageTestSupport {
     public void testValueWithSpace() {
         exchange.getIn().setBody("Hello Big World");
         assertPredicate("${in.body} == 'Hello Big World'", true);
+        assertPredicate("${in.body} == ${body}", true);
     }
 
     @Test
@@ -805,6 +806,38 @@ public void testNotEndsWith() {
         assertPredicate("${in.body} !endsWith 'Hi'", true);
     }
 
+    @Test
+    public void testElvis() {
+        exchange.getIn().setBody(false);
+        assertPredicate("${body} ?: 'true'", true);
+        assertPredicate("${body} ?: 'false'", false);
+        exchange.getIn().setBody("Hello");
+        assertPredicate("${body} ?: 'false'", true);
+        exchange.getIn().setBody(0);
+        assertPredicate("${body} ?: 'true'", true);
+        assertPredicate("${body} ?: 'false'", false);
+        exchange.getIn().setBody(1);
+        assertPredicate("${body} ?: 'true'", true);
+        assertPredicate("${body} ?: 'false'", true);
+
+        exchange.getIn().setBody(null);
+        assertExpression("${body} ?: 'World'", "World");
+        exchange.getIn().setBody("");
+        assertExpression("${body} ?: 'World'", "World");
+        exchange.getIn().setBody("Hello");
+        assertExpression("${body} ?: 'World'", "Hello");
+        exchange.getIn().setBody(false);
+        assertExpression("${body} ?: 'World'", "World");
+        exchange.getIn().setBody(true);
+        assertExpression("${body} ?: 'World'", true);
+        exchange.getIn().setHeader("myHeader", "Camel");
+        assertExpression("${header.myHeader} ?: 'World'", "Camel");
+        exchange.getIn().setBody(0);
+        assertExpression("${body} ?: 'World'", "World");
+        exchange.getIn().setBody(1);
+        assertExpression("${body} ?: 'World'", 1);
+    }
+
     @Override
     protected String getLanguageName() {
         return "csimple";

core/camel-core-languages/src/main/docs/modules/languages/pages/simple-language.adoc

@@ -336,6 +336,22 @@ And the following unary operators can be used:
 |`--` | To decrement a number by one. The left-hand side must be a function, otherwise parsed as literal.
 |====
 
+And the following other operators can be used:
+
+[width="100%",cols="50%,50%",options="header",]
+|====
+|Operator |Description
+|`?:` | The elvis operator returns the left-hand side if it has an effective Boolean value of true, otherwise it returns the right-hand side. This is useful for providing fallback values when an expression may evaluate to a value with an effective Boolean value of false (such as `null`, `false`, `0`, empty/blank string).
+|====
+
+For example the following elvis operator will return the username header unless its null or empty, which
+then the default value of `Guest` is returned.
+
+[source,java]
+----
+simple("${header.username} ?: 'Guest'");
+----
+
 And the following special symbols:
 
 [width="100%",cols="50%,50%",options="header",]

core/camel-core-languages/src/main/java/org/apache/camel/language/csimple/CSimpleHelper.java

@@ -979,4 +979,12 @@ public static int size(Exchange exchange, Object value) {
         return 0;
     }
 
+    public static Object elvis(Exchange exchange, Object left, Object right) {
+        if (left == null || Boolean.FALSE == left || ObjectHelper.isEmpty(left) || ObjectHelper.equal(0, left)) {
+            return right;
+        } else {
+            return left;
+        }
+    }
+
 }

core/camel-core-languages/src/main/java/org/apache/camel/language/simple/BaseSimpleParser.java

@@ -23,9 +23,11 @@
 import java.util.List;
 
 import org.apache.camel.CamelContext;
+import org.apache.camel.Predicate;
 import org.apache.camel.language.simple.ast.Block;
 import org.apache.camel.language.simple.ast.BlockEnd;
 import org.apache.camel.language.simple.ast.BlockStart;
+import org.apache.camel.language.simple.ast.OtherExpression;
 import org.apache.camel.language.simple.ast.SimpleNode;
 import org.apache.camel.language.simple.ast.UnaryExpression;
 import org.apache.camel.language.simple.types.SimpleParserException;
@@ -205,6 +207,69 @@ protected void prepareUnaryExpressions() {
         Collections.reverse(nodes);
     }
 
+    /**
+     * Prepares other expressions.
+     * <p/>
+     * This process prepares the other expressions in the AST. This is done by linking the other operator with both the
+     * right and left hand side nodes, to have the AST graph updated and prepared properly.
+     * <p/>
+     * So when the AST node is later used to create the {@link Predicate}s to be used by Camel then the AST graph has a
+     * linked and prepared graph of nodes which represent the input expression.
+     */
+    protected void prepareOtherExpressions() {
+        Deque<SimpleNode> stack = new ArrayDeque<>();
+
+        SimpleNode left = null;
+        for (int i = 0; i < nodes.size(); i++) {
+            if (left == null) {
+                left = i > 0 ? nodes.get(i - 1) : null;
+            }
+            SimpleNode token = nodes.get(i);
+            SimpleNode right = i < nodes.size() - 1 ? nodes.get(i + 1) : null;
+
+            if (token instanceof OtherExpression other) {
+                // remember the other operator
+                String operator = other.getOperator().toString();
+
+                if (left == null) {
+                    throw new SimpleParserException(
+                            "Other operator " + operator + " has no left hand side token", token.getToken().getIndex());
+                }
+                if (!other.acceptLeftNode(left)) {
+                    throw new SimpleParserException(
+                            "Other operator " + operator + " does not support left hand side token " + left.getToken(),
+                            token.getToken().getIndex());
+                }
+                if (right == null) {
+                    throw new SimpleParserException(
+                            "Other operator " + operator + " has no right hand side token", token.getToken().getIndex());
+                }
+                if (!other.acceptRightNode(right)) {
+                    throw new SimpleParserException(
+                            "Other operator " + operator + " does not support right hand side token " + right.getToken(),
+                            token.getToken().getIndex());
+                }
+
+                // pop previous as we need to replace it with this other operator
+                stack.pop();
+                stack.push(token);
+                // advantage after the right hand side
+                i++;
+                // this token is now the left for the next loop
+                left = token;
+            } else {
+                // clear left
+                left = null;
+                stack.push(token);
+            }
+        }
+
+        nodes.clear();
+        nodes.addAll(stack);
+        // must reverse as it was added from a stack that is reverse
+        Collections.reverse(nodes);
+    }
+
     // --------------------------------------------------------------
     // grammar
     // --------------------------------------------------------------

core/camel-core-languages/src/main/java/org/apache/camel/language/simple/SimpleExpressionParser.java

@@ -25,10 +25,12 @@
 import org.apache.camel.Expression;
 import org.apache.camel.language.simple.ast.LiteralExpression;
 import org.apache.camel.language.simple.ast.LiteralNode;
+import org.apache.camel.language.simple.ast.OtherExpression;
 import org.apache.camel.language.simple.ast.SimpleFunctionEnd;
 import org.apache.camel.language.simple.ast.SimpleFunctionStart;
 import org.apache.camel.language.simple.ast.SimpleNode;
 import org.apache.camel.language.simple.ast.UnaryExpression;
+import org.apache.camel.language.simple.types.OtherOperatorType;
 import org.apache.camel.language.simple.types.SimpleIllegalSyntaxException;
 import org.apache.camel.language.simple.types.SimpleParserException;
 import org.apache.camel.language.simple.types.SimpleToken;
@@ -97,23 +99,28 @@ protected List<SimpleNode> parseTokens() {
         // parse the expression using the following grammar
         nextToken();
         while (!token.getType().isEol()) {
-            // an expression supports just template (eg text), functions, or unary operator
+            // an expression supports just template (eg text), functions, unary, or other operator
             templateText();
             functionText();
             unaryOperator();
+            otherOperator();
             nextToken();
         }
 
         // now after parsing, we need a bit of work to do, to make it easier to turn the tokens
         // into an ast, and then from the ast, to Camel expression(s).
         // hence why there are a number of tasks going on below to accomplish this
 
+        // remove any ignorable white space tokens
+        removeIgnorableWhiteSpaceTokens();
         // turn the tokens into the ast model
         parseAndCreateAstModel();
         // compact and stack blocks (eg function start/end)
         prepareBlocks();
         // compact and stack unary operators
         prepareUnaryExpressions();
+        // compact and stack other expressions
+        prepareOtherExpressions();
 
         return nodes;
     }
@@ -135,6 +142,34 @@ protected Expression doParseExpression() {
         }
     }
 
+    /**
+     * Removes any ignorable whitespace tokens before and after other operators.
+     * <p/>
+     * During the initial parsing (input -> tokens), then there may be excessive whitespace tokens, which can safely be
+     * removed, which makes the succeeding parsing easier.
+     */
+    private void removeIgnorableWhiteSpaceTokens() {
+        // white space should be removed before and after the other operator
+        List<SimpleToken> toRemove = new ArrayList<>();
+        for (int i = 1; i < tokens.size() - 1; i++) {
+            SimpleToken prev = tokens.get(i - 1);
+            SimpleToken cur = tokens.get(i);
+            SimpleToken next = tokens.get(i + 1);
+            if (cur.getType().isOther()) {
+                if (prev.getType().isWhitespace()) {
+                    toRemove.add(prev);
+                }
+                if (next.getType().isWhitespace()) {
+                    toRemove.add(next);
+                }
+            }
+        }
+
+        if (!toRemove.isEmpty()) {
+            tokens.removeAll(toRemove);
+        }
+    }
+
     protected void parseAndCreateAstModel() {
         // we loop the tokens and create a sequence of ast nodes
 
@@ -187,10 +222,12 @@ private SimpleNode createNode(SimpleToken token, AtomicInteger functions) {
             functions.decrementAndGet();
             return new SimpleFunctionEnd(token);
         } else if (token.getType().isUnary()) {
-            // there must be a end function as previous, to let this be a unary function
+            // there must be an end function as previous, to let this be a unary function
             if (!nodes.isEmpty() && nodes.get(nodes.size() - 1) instanceof SimpleFunctionEnd) {
                 return new UnaryExpression(token);
             }
+        } else if (token.getType().isOther()) {
+            return new OtherExpression(token);
         }
 
         // by returning null, we will let the parser determine what to do
@@ -268,10 +305,12 @@ static void parseLiteralNode(StringBuilder sb, SimpleNode node, String exp) {
     // - template = literal texts with can contain embedded functions
     // - function = simple functions such as ${body} etc.
     // - unary operator = operator attached to the left-hand side node
+    // - other operator = operator attached to both the left and right hand side nodes
 
     protected void templateText() {
-        // for template, we accept anything but functions
-        while (!token.getType().isFunctionStart() && !token.getType().isFunctionEnd() && !token.getType().isEol()) {
+        // for template, we accept anything but functions / other operator
+        while (!token.getType().isFunctionStart() && !token.getType().isFunctionEnd() && !token.getType().isEol()
+                && !token.getType().isOther()) {
             nextToken();
         }
     }
@@ -296,6 +335,36 @@ protected boolean functionText() {
         return false;
     }
 
+    protected boolean otherOperator() {
+        if (accept(TokenType.otherOperator)) {
+            // remember the other operator
+            OtherOperatorType operatorType = OtherOperatorType.asOperator(token.getText());
+
+            nextToken();
+            // there should be at least one whitespace after the operator
+            expectAndAcceptMore(TokenType.whiteSpace);
+
+            // then we expect either some quoted text, another function, or a numeric, boolean or null value
+            if (singleQuotedLiteralWithFunctionsText()
+                    || doubleQuotedLiteralWithFunctionsText()
+                    || functionText()
+                    || numericValue()
+                    || booleanValue()
+                    || nullValue()) {
+                // then after the right hand side value, there should be a whitespace if there is more tokens
+                nextToken();
+                if (!token.getType().isEol()) {
+                    expect(TokenType.whiteSpace);
+                }
+            } else {
+                throw new SimpleParserException(
+                        "Other operator " + operatorType + " does not support token " + token, token.getIndex());
+            }
+            return true;
+        }
+        return false;
+    }
+
     protected boolean unaryOperator() {
         if (accept(TokenType.unaryOperator)) {
             nextToken();
@@ -305,4 +374,46 @@ protected boolean unaryOperator() {
         }
         return false;
     }
+
+    protected boolean singleQuotedLiteralWithFunctionsText() {
+        if (accept(TokenType.singleQuote)) {
+            nextToken(TokenType.singleQuote, TokenType.eol, TokenType.functionStart, TokenType.functionEnd);
+            while (!token.getType().isSingleQuote() && !token.getType().isEol()) {
+                // we need to loop until we find the ending single quote, or the eol
+                nextToken(TokenType.singleQuote, TokenType.eol, TokenType.functionStart, TokenType.functionEnd);
+            }
+            expect(TokenType.singleQuote);
+            return true;
+        }
+        return false;
+    }
+
+    protected boolean doubleQuotedLiteralWithFunctionsText() {
+        if (accept(TokenType.doubleQuote)) {
+            nextToken(TokenType.doubleQuote, TokenType.eol, TokenType.functionStart, TokenType.functionEnd);
+            while (!token.getType().isDoubleQuote() && !token.getType().isEol()) {
+                // we need to loop until we find the ending double quote, or the eol
+                nextToken(TokenType.doubleQuote, TokenType.eol, TokenType.functionStart, TokenType.functionEnd);
+            }
+            expect(TokenType.doubleQuote);
+            return true;
+        }
+        return false;
+    }
+
+    protected boolean numericValue() {
+        return accept(TokenType.numericValue);
+        // no other tokens to check so do not use nextToken
+    }
+
+    protected boolean booleanValue() {
+        return accept(TokenType.booleanValue);
+        // no other tokens to check so do not use nextToken
+    }
+
+    protected boolean nullValue() {
+        return accept(TokenType.nullValue);
+        // no other tokens to check so do not use nextToken
+    }
+
 }