camel-core - Add safeQuote function to simple language

Author: davsclaus

catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/languages/simple.json

@@ -2635,6 +2635,53 @@ public void testQuote() {
         assertEquals("\"Hi\"", s);
     }
 
+    @Test
+    public void testSafeQuote() {
+        exchange.getMessage().setBody("Hello World");
+
+        Expression expression = context.resolveLanguage("csimple").createExpression("${safeQuote()}");
+        String s = expression.evaluate(exchange, String.class);
+        assertEquals("\"Hello World\"", s);
+
+        expression = context.resolveLanguage("csimple").createExpression("${safeQuote(${body})}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("\"Hello World\"", s);
+
+        expression = context.resolveLanguage("csimple").createExpression("${safeQuote('Hi')}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("\"Hi\"", s);
+
+        expression = context.resolveLanguage("csimple").createExpression("${safeQuote(''Hi'')}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("\"Hi\"", s);
+
+        exchange.getMessage().setBody(123);
+        expression = context.resolveLanguage("csimple").createExpression("${safeQuote()}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("123", s);
+
+        expression = context.resolveLanguage("csimple").createExpression("${safeQuote(${body})}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("123", s);
+
+        exchange.getMessage().setBody(true);
+        expression = context.resolveLanguage("csimple").createExpression("${safeQuote()}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("true", s);
+
+        expression = context.resolveLanguage("csimple").createExpression("${safeQuote(${body})}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("true", s);
+
+        Map<String, String> m = new LinkedHashMap<>();
+        m.put("A", "1");
+        m.put("B", "2");
+        exchange.getMessage().setBody(m);
+        expression = context.resolveLanguage("csimple").createExpression("${safeQuote()}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("\"{A=1, B=2}\"", s);
+    }
+
     @Test
     public void testTrim() {
         exchange.getMessage().setBody("   Hello World ");
@@ -2879,7 +2926,7 @@ public void testAbs() {
         Integer i = expression.evaluate(exchange, Integer.class);
         assertEquals(987, i);
 
-        expression = context.resolveLanguage("simple").createExpression("${abs(-5)}");
+        expression = context.resolveLanguage("csimple").createExpression("${abs(-5)}");
         i = expression.evaluate(exchange, Integer.class);
         assertEquals(5, i);
 

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

@@ -35,8 +35,8 @@ public class JsonPathSimpleInitBlockFunctionTest extends CamelTestSupport {
               "id": "$id",
               "type": "$type",
               "amount": $price,
-              "oldStatus": $price ~> $level() ~> ${quote()}
-              "status": ${newStatus($price)} ~> $level() ~> ${quote()}
+              "oldStatus": $price ~> $level() ~> ${safeQuote()}
+              "status": ${newStatus($price)} ~> $level() ~> ${safeQuote()}
             }
             """;
 

components/camel-jsonpath/src/test/java/org/apache/camel/jsonpath/JsonPathSimpleInitBlockFunctionTest.java

@@ -460,6 +460,8 @@ The generator supports different kinds `default`, `classic`, `short`, `simple` a
 |`pad(exp,width,separator)` | `String` | Pads the expression with extra padding if necessary, according the total width The separator is by default a space. If the width is negative then padding to the right, otherwise to the left.
 |`replace(from,to)` | `String` | Replace all the string values in the message body. To make it easier to replace single and double quotes, then you can use XML escaped values `\"` as double quote, `\'` as single quote, and `\∅` as empty value.
 |`replace(from,to,exp)` | `String` | Replace all the string values in the given expression. To make it easier to replace single and double quotes, then you can use XML escaped values `\"` as double quote, `\'` as single quote, and `\∅` as empty value.
+|`safeQuote() | `String` | Returns the message body safely quoted if needed
+|`safeQuote(exp) | `String` | Returns the expression safely quoted if needed
 |`substring(num1)` | `String` | Returns a substring of the message body. If the number is positive, then the returned string is clipped from the beginning. If the number is negative, then the returned string is clipped from the ending.
 |`substring(num1,num2)` | `String` | Returns a substring of the message body. If the number is positive, then the returned string is clipped from the beginning. If the number is negative, then the returned string is clipped from the ending.
 |`substring(num1,num2,exp)` | `String` | Returns a substring of the given expression. If the number is positive, then the returned string is clipped from the beginning. If the number is negative, then the returned string is clipped from the ending.
@@ -532,6 +534,22 @@ If the value is currently in single quote, then this will be converted to double
 If the message body contains `Hello World` then `${quote()}` returns `"Hello World"`.
 And using `${quote('Hi from me')}` then `"Hi from me"` is returned.
 
+The `safeQuote` function is quoting the value depending on the value type
+(uses the same logic as `kindOfType` function). In essence values that are null, boolean or numbers are not quoted,
+while everything else is. The `safeQuote` function is useful when working with JSon data.
+
+For example when doing JSon to JSon mapping you can extract values form the source document,
+to be included in the output, but the values may or may not need to be quoted. Then you can use the `~>` chain operator
+to call the `safeQuote` function as shown below:
+
+[source,text]
+----
+{
+   "id": ${jsonpath($.id)} ~> ${safeQuote()}
+   "total": ${jsonpath($.amount)} ~> ${safeQuote()}
+}
+----
+
 
 === XML & JSon Functions
 

core/camel-core-languages/src/generated/resources/META-INF/org/apache/camel/language/simple/simple.json

@@ -1062,6 +1062,19 @@ public static String quote(Exchange exchange, Object value) {
         return body;
     }
 
+    public static Object safeQuote(Exchange exchange, Object value) {
+        if (value == null) {
+            return null;
+        }
+        String type = kindOfType(exchange, value);
+        if ("string".equals(type) || "array".equals(type) || "object".equals(type)) {
+            String body = exchange.getContext().getTypeConverter().tryConvertTo(String.class, exchange, value);
+            body = StringHelper.removeLeadingAndEndingQuotes(body);
+            value = StringQuoteHelper.doubleQuote(body);
+        }
+        return value;
+    }
+
     public static String trim(Exchange exchange, Object value) {
         String body;
         if (value != null) {

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

@@ -337,6 +337,10 @@ public final class SimpleConstants {
               label = "function")
     public static final String ROUTE_ID = "routeId";
 
+    @Metadata(description = "Returns the message body (or expression) safely quoted if needed",
+              label = "function", javaType = "String")
+    public static final String SAFE_QUOTE = "safeQuote(exp)";
+
     @Metadata(description = "Sets an attachment with payload from the message body/expression.",
               label = "function", javaType = "Object")
     public static final String SET_ATTACHMENT = "setVariable(key,exp)";

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

@@ -643,6 +643,68 @@ public String toString() {
         };
     }
 
+    /**
+     * Safe quotes the given expressions (uses message body if expression is null) if necessary.
+     */
+    public static Expression safeQuoteExpression(final String expression) {
+        return new ExpressionAdapter() {
+            private Expression exp;
+
+            @Override
+            public void init(CamelContext context) {
+                if (expression != null) {
+                    exp = context.resolveLanguage("simple").createExpression(expression);
+                    exp.init(context);
+                }
+            }
+
+            @Override
+            public Object evaluate(Exchange exchange) {
+                Object value;
+                if (exp != null) {
+                    value = exp.evaluate(exchange, Object.class);
+                } else {
+                    value = exchange.getMessage().getBody(Object.class);
+                }
+                if (value != null) {
+                    String type = kindOfType(value);
+                    if ("string".equals(type) || "array".equals(type) || "object".equals(type)) {
+                        String body = exchange.getContext().getTypeConverter().tryConvertTo(String.class, exchange, value);
+                        body = StringHelper.removeLeadingAndEndingQuotes(body);
+                        value = StringQuoteHelper.doubleQuote(body);
+                    }
+                }
+                return value;
+            }
+
+            private String kindOfType(Object value) {
+                Class<?> type = value.getClass();
+                if (ObjectHelper.isNumericType(type)) {
+                    return "number";
+                } else if (boolean.class == type || Boolean.class == type) {
+                    return "boolean";
+                } else if (value instanceof CharSequence) {
+                    return "string";
+                } else if (ObjectHelper.isPrimitiveArrayType(type) || value instanceof Collection
+                           || value instanceof Map<?, ?>) {
+                    return "array";
+                } else {
+                    return "object";
+                }
+            }
+
+
+            @Override
+            public String toString() {
+                if (expression != null) {
+                    return "safeQuote(" + expression + ")";
+                } else {
+                    return "safeQuote()";
+                }
+            }
+        };
+    }
+
     /**
      * Double quotes the given expressions (uses message body if expression is null)
      */

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

@@ -1204,6 +1204,16 @@ private Expression createSimpleExpressionMisc(String function) {
             }
             return SimpleExpressionBuilder.quoteExpression(exp);
         }
+        // safeQuote function
+        remainder = ifStartsWithReturnRemainder("safeQuote(", function);
+        if (remainder != null) {
+            String exp = null;
+            String value = StringHelper.beforeLast(remainder, ")");
+            if (ObjectHelper.isNotEmpty(value)) {
+                exp = StringHelper.removeQuotes(value);
+            }
+            return SimpleExpressionBuilder.safeQuoteExpression(exp);
+        }
 
         // trim function
         remainder = ifStartsWithReturnRemainder("trim(", function);
@@ -2977,6 +2987,30 @@ private String createCodeExpressionMisc(CamelContext camelContext, String functi
             }
             return "Object o = " + exp + ";\n        return quote(exchange, o);";
         }
+        // safaeQuote function
+        remainder = ifStartsWithReturnRemainder("safeQuote(", function);
+        if (remainder != null) {
+            String exp = null;
+            String values = StringHelper.beforeLast(remainder, ")");
+            if (ObjectHelper.isNotEmpty(values)) {
+                String[] tokens = codeSplitSafe(values, ',', true, true);
+                if (tokens.length != 1) {
+                    throw new SimpleParserException(
+                            "Valid syntax: ${safeQuote(exp)} was: " + function, token.getIndex());
+                }
+                // single quotes should be double quotes
+                String s = tokens[0];
+                if (StringHelper.isSingleQuoted(s)) {
+                    s = StringHelper.removeLeadingAndEndingQuotes(s);
+                    s = StringQuoteHelper.doubleQuote(s);
+                }
+                exp = s;
+            }
+            if (ObjectHelper.isEmpty(exp)) {
+                exp = "body";
+            }
+            return "Object o = " + exp + ";\n        return safeQuote(exchange, o);";
+        }
 
         // trim function
         remainder = ifStartsWithReturnRemainder("trim(", function);

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

@@ -2960,6 +2960,53 @@ public void testQuote() {
         assertEquals("\"Hi\"", s);
     }
 
+    @Test
+    public void testSafeQuote() {
+        exchange.getMessage().setBody("Hello World");
+
+        Expression expression = context.resolveLanguage("simple").createExpression("${safeQuote()}");
+        String s = expression.evaluate(exchange, String.class);
+        assertEquals("\"Hello World\"", s);
+
+        expression = context.resolveLanguage("simple").createExpression("${safeQuote(${body})}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("\"Hello World\"", s);
+
+        expression = context.resolveLanguage("simple").createExpression("${safeQuote('Hi')}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("\"Hi\"", s);
+
+        expression = context.resolveLanguage("simple").createExpression("${safeQuote(''Hi'')}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("\"Hi\"", s);
+
+        exchange.getMessage().setBody(123);
+        expression = context.resolveLanguage("simple").createExpression("${safeQuote()}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("123", s);
+
+        expression = context.resolveLanguage("simple").createExpression("${safeQuote(${body})}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("123", s);
+
+        exchange.getMessage().setBody(true);
+        expression = context.resolveLanguage("simple").createExpression("${safeQuote()}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("true", s);
+
+        expression = context.resolveLanguage("simple").createExpression("${safeQuote(${body})}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("true", s);
+
+        Map<String, String> m = new LinkedHashMap<>();
+        m.put("A", "1");
+        m.put("B", "2");
+        exchange.getMessage().setBody(m);
+        expression = context.resolveLanguage("simple").createExpression("${safeQuote()}");
+        s = expression.evaluate(exchange, String.class);
+        assertEquals("\"{A=1, B=2}\"", s);
+    }
+
     @Test
     public void testTrim() {
         exchange.getMessage().setBody("   Hello World ");