Expression default value with DOUBLE_COLON (#193)

smallrye · Oct 25, 2022 · eb96399 · eb96399
1 parent 3a99006
commit eb96399
Show file tree

Hide file tree

Showing 2 changed files with 72 additions and 10 deletions.
diff --git a/expression/src/main/java/io/smallrye/common/expression/Expression.java b/expression/src/main/java/io/smallrye/common/expression/Expression.java
@@ -299,13 +299,22 @@ private static Node parseString(Itr itr, final boolean allowExpr, final boolean
                                 start = itr.getNextIdx();
                                 continue;
                             } else if (itr.peekNext() == ':') {
-                                if (flags.contains(Flag.DOUBLE_COLON) && itr.hasNext() && itr.peekNext() == ':') {
-                                    // TP 7
-                                    // OK actually the whole thing is really going to be part of the key
-                                    // Best approach is, rewind and do it over again, but without end-on-colon
-                                    itr.rewind(start);
-                                    keyNode = parseString(itr, !flags.contains(Flag.NO_RECURSE_KEY), true, false, flags);
-                                    list.add(new ExpressionNode(general, keyNode, Node.NULL));
+                                if (flags.contains(Flag.DOUBLE_COLON)) {
+                                    itr.next();
+                                    if (itr.hasNext() && itr.peekNext() == ':') {
+                                        // TP 7
+                                        // OK actually the whole thing is really going to be part of the key
+                                        // Best approach is, rewind and do it over again, but without end-on-colon
+                                        itr.rewind(start);
+                                        keyNode = parseString(itr, !flags.contains(Flag.NO_RECURSE_KEY), true, false, flags);
+                                        list.add(new ExpressionNode(general, keyNode, Node.NULL));
+                                    } else {
+                                        // TP 7.5
+                                        // A single colon was found, so it is a default
+                                        final Node defaultValueNode = parseString(itr, !flags.contains(Flag.NO_RECURSE_DEFAULT),
+                                                true, false, flags);
+                                        list.add(new ExpressionNode(general, keyNode, defaultValueNode));
+                                    }
                                 } else {
                                     // TP 8
                                     itr.next(); // consume it

diff --git a/expression/src/test/java/io/smallrye/common/expression/ExpressionTestCase.java b/expression/src/test/java/io/smallrye/common/expression/ExpressionTestCase.java
@@ -212,20 +212,59 @@ public void testPoint6() {
 
     @Test
     public void testPoint7() {
-        final Expression expression = Expression.compile("${expr::baz}", Expression.Flag.DOUBLE_COLON);
+        Expression expression = Expression.compile("${expr::baz}", Expression.Flag.DOUBLE_COLON);
         assertEquals("result", expression.evaluate((c, b) -> {
             assertEquals("expr::baz", c.getKey());
             b.append("result");
         }));
+
+        expression = Expression.compile("${expr::baz::baz}", Expression.Flag.DOUBLE_COLON);
+        assertEquals("result", expression.evaluate((c, b) -> {
+            assertEquals("expr::baz::baz", c.getKey());
+            b.append("result");
+        }));
+
+        expression = Expression.compile("${foo.bar::baz:something}", Expression.Flag.DOUBLE_COLON);
+        assertEquals("result", expression.evaluate((c, b) -> {
+            assertEquals("foo.bar::baz:something", c.getKey());
+            b.append("result");
+        }));
+    }
+
+    @Test
+    void testPoint7_5() {
+        Expression expression = Expression.compile("${foo.bar:baz::something}", Expression.Flag.DOUBLE_COLON);
+        assertEquals("baz::something", expression.evaluate((c, b) -> {
+            assertEquals("foo.bar", c.getKey());
+            c.expandDefault();
+        }));
     }
 
     @Test
     public void testPoint8() {
-        final Expression expression = Expression.compile("${expr::baz}");
+        Expression expression = Expression.compile("${expr::baz}");
         assertEquals(":baz", expression.evaluate((c, b) -> {
             assertEquals("expr", c.getKey());
             c.expandDefault();
         }));
+
+        expression = Expression.compile("${expr::baz:something}");
+        assertEquals(":baz:something", expression.evaluate((c, b) -> {
+            assertEquals("expr", c.getKey());
+            c.expandDefault();
+        }));
+
+        expression = Expression.compile("${expr:baz::something}");
+        assertEquals("baz::something", expression.evaluate((c, b) -> {
+            assertEquals("expr", c.getKey());
+            c.expandDefault();
+        }));
+
+        expression = Expression.compile("${expr:baz:something}");
+        assertEquals("baz:something", expression.evaluate((c, b) -> {
+            assertEquals("expr", c.getKey());
+            c.expandDefault();
+        }));
     }
 
     @Test
@@ -404,12 +443,26 @@ public void testPoint27() {
 
     @Test
     public void testPoint28() {
-        final Expression expression = Expression.compile("${foo:bar}");
+        Expression expression = Expression.compile("${foo:bar}");
         assertEquals("bar", expression.evaluate((c, b) -> {
             assertEquals("foo", c.getKey());
             assertEquals("bar", c.getExpandedDefault());
             c.expandDefault();
         }));
+
+        expression = Expression.compile("${foo:bar:baz}");
+        assertEquals("bar:baz", expression.evaluate((c, b) -> {
+            assertEquals("foo", c.getKey());
+            assertEquals("bar:baz", c.getExpandedDefault());
+            c.expandDefault();
+        }));
+
+        expression = Expression.compile("${foo:bar::baz}");
+        assertEquals("bar::baz", expression.evaluate((c, b) -> {
+            assertEquals("foo", c.getKey());
+            assertEquals("bar::baz", c.getExpandedDefault());
+            c.expandDefault();
+        }));
     }
 
     @Test