Merge pull request quarkusio#47526 from mkouba/issue-34315

Qute: introduce equals operator for output expressions

Author: mkouba

docs/src/main/asciidoc/qute-reference.adoc

@@ -399,28 +399,32 @@ NOTE: The current context can be accessed via the implicit binding `this`.
 |===
 |Name |Description	|Examples
 
-|Elvis Operator
+|Elvis Operator: `?:`
 |Outputs the default value if the previous part cannot be resolved or resolves to `null`.
 |`{person.name ?: 'John'}`, `{person.name or 'John'}`, `{person.name.or('John')}`
 
-|orEmpty
+|`orEmpty`
 |Outputs an empty list if the previous part cannot be resolved or resolves to `null`.
 |`{pets.orEmpty.size}` outputs `0` if `pets` is not resolvable or `null`
 
-|Ternary Operator
+|Ternary Operator: `condition ? ifTrue : ifFalse`
 |Shorthand for if-then-else statement. Unlike in <<if_section>> nested operators are not supported.
 |`{item.isActive ? item.name : 'Inactive item'}` outputs the value of `item.name` if `item.isActive` resolves to `true`.
 
-|Logical AND Operator
+|Logical AND Operator: `&&`
 |Outputs `true` if both parts are not `falsy` as described in the <<if_section>>.
 The parameter is only evaluated if needed.
 |`{person.isActive && person.hasStyle}`
 
-|Logical OR Operator
+|Logical OR Operator: `\|\|`
 |Outputs `true` if any of the parts is not `falsy` as described in the <<if_section>>.
 The parameter is only evaluated if needed.
 |`{person.isActive \|\| person.hasStyle}`
 
+|Equals Operator: `==`/`eq`/`is`
+|Outputs `true` if the base object is equal to the argument.
+|`{obj1 is obj2 ? 'Equal' : 'Inequal'}`, `{obj1 == obj2 ? 'Equal' : 'Inequal'}`, `{obj1.eq(obj2) ? 'Equal' : 'Inequal'}`
+
 |===
 
 TIP: The condition in a ternary operator evaluates to `true` if the value is not considered `falsy` as described in <<if_section>>.
@@ -2263,22 +2267,23 @@ NOTE: Superfluous matching conditions are ignored. The conditions sorted by prio
 
 An extension method may declare parameters.
 If no namespace is specified then the first parameter that is not annotated with `@TemplateAttribute` is used to pass the base object, i.e. `org.acme.Item` in the first example.
-If matching any name or using a regular expression, then a string method parameter needs to be used to pass the property name.
+If matching any name or using a regular expression, then a string method parameter (not not annotated with `@TemplateAttribute`) needs to be used to pass the property name.
 Parameters annotated with `@TemplateAttribute` are obtained via `TemplateInstance#getAttribute()`.
-All other parameters are resolved when rendering the template and passed to the extension method.
+All other parameters are treated as virtual method parameters and resolved when rendering the template and passed to the extension method.
 
 .Multiple Parameters Example
 [source,java]
 ----
 @TemplateExtension
 class BigDecimalExtensions {
 
-    static BigDecimal scale(BigDecimal val, int scale, RoundingMode mode) { <1>
+    @TemplateExtension(matchNames = {"scale", "setScale"})
+    static BigDecimal scale(BigDecimal val, String ignoredName, int scale, RoundingMode mode) { <1>
         return val.setScale(scale, mode);
     }
 }
 ----
-<1> This method matches an expression with base object of the type `BigDecimal.class`, with the `scale` virtual method name and two virtual method parameters.
+<1> This method matches an expression with base object of the type `BigDecimal.class`, with the `scale()`/`setScale()` virtual method name and two virtual method parameters - `scale` and `mode`.
 
 [source,html]
 ----

extensions/qute/deployment/src/main/java/io/quarkus/qute/deployment/QuteProcessor.java

@@ -155,6 +155,7 @@
 import io.quarkus.qute.runtime.extensions.ConfigTemplateExtensions;
 import io.quarkus.qute.runtime.extensions.MapTemplateExtensions;
 import io.quarkus.qute.runtime.extensions.NumberTemplateExtensions;
+import io.quarkus.qute.runtime.extensions.ObjectsTemplateExtensions;
 import io.quarkus.qute.runtime.extensions.OrOperatorTemplateExtensions;
 import io.quarkus.qute.runtime.extensions.StringTemplateExtensions;
 import io.quarkus.qute.runtime.extensions.TimeTemplateExtensions;
@@ -285,7 +286,8 @@ AdditionalBeanBuildItem additionalBeans() {
                 .addBeanClasses(EngineProducer.class, TemplateProducer.class, ContentTypes.class, Template.class,
                         TemplateInstance.class, CollectionTemplateExtensions.class,
                         MapTemplateExtensions.class, NumberTemplateExtensions.class, ConfigTemplateExtensions.class,
-                        TimeTemplateExtensions.class, StringTemplateExtensions.class, OrOperatorTemplateExtensions.class)
+                        TimeTemplateExtensions.class, StringTemplateExtensions.class, OrOperatorTemplateExtensions.class,
+                        ObjectsTemplateExtensions.class)
                 .build();
     }
 
@@ -422,7 +424,7 @@ && isNotLocatedByCustomTemplateLocator(locatorPatternsBuildItem.getLocationPatte
                 }
                 reservedNames.add(method.name());
             }
-            for (ClassInfo recordClass : index.getIndex().getAllKnownImplementors(recordInterfaceName)) {
+            for (ClassInfo recordClass : index.getIndex().getAllKnownImplementations(recordInterfaceName)) {
                 if (!recordClass.isRecord()) {
                     continue;
                 }

extensions/qute/deployment/src/test/java/io/quarkus/qute/deployment/extensions/ObjectsTemplateExtensionsTest.java

@@ -0,0 +1,43 @@
+package io.quarkus.qute.deployment.extensions;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.function.IntFunction;
+
+import jakarta.inject.Inject;
+
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.qute.Template;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class ObjectsTemplateExtensionsTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .withApplicationRoot(root -> root
+                    .addAsResource(new StringAsset(
+                            "{name == 'hallo' ? 'yes' : 'no'}::{name eq 'hello' ? 'yes' : 'no'}::{name is 'hi' ? 'yes' : 'no'}::{#if name eq 'hallo'}ok{/if}"
+                                    + "::{fun.apply(name eq 'hello' ? 0 : 7)}"),
+                            "templates/foo.html"));
+
+    @Inject
+    Template foo;
+
+    @Test
+    public void testEquals() {
+        assertEquals("yes::no::no::ok::ok", foo
+                .data("name", "hallo")
+                .data("fun", new IntFunction<String>() {
+
+                    @Override
+                    public String apply(int value) {
+                        return value > 5 ? "ok" : "nok";
+                    }
+                })
+                .render());
+    }
+
+}

extensions/qute/runtime/src/main/java/io/quarkus/qute/runtime/extensions/ObjectsTemplateExtensions.java

@@ -0,0 +1,16 @@
+package io.quarkus.qute.runtime.extensions;
+
+import java.util.Objects;
+
+import jakarta.enterprise.inject.Vetoed;
+
+import io.quarkus.qute.TemplateExtension;
+
+@Vetoed // Make sure no bean is created from this class
+public class ObjectsTemplateExtensions {
+
+    @TemplateExtension(matchNames = { "eq", "==", "is" })
+    static boolean eq(Object value, String ignoredName, Object other) {
+        return Objects.equals(value, other);
+    }
+}

independent-projects/qute/core/src/main/java/io/quarkus/qute/EngineBuilder.java

@@ -156,7 +156,7 @@ public EngineBuilder addDefaultValueResolvers() {
                 ValueResolvers.thisResolver(), ValueResolvers.orResolver(), ValueResolvers.trueResolver(),
                 ValueResolvers.logicalAndResolver(), ValueResolvers.logicalOrResolver(), ValueResolvers.orEmpty(),
                 ValueResolvers.arrayResolver(), ValueResolvers.plusResolver(), ValueResolvers.minusResolver(),
-                ValueResolvers.modResolver(), ValueResolvers.numberValueResolver());
+                ValueResolvers.modResolver(), ValueResolvers.numberValueResolver(), ValueResolvers.equalsResolver());
     }
 
     /**

independent-projects/qute/core/src/main/java/io/quarkus/qute/TemplateExtension.java

@@ -40,8 +40,7 @@
  * <h2>Matching by name</h2>
  *
  * By default, the method name is used to match the expression property/method name. However, it is possible to specify the
- * matching name with
- * {@link #matchName()}.
+ * matching name with {@link #matchName()}.
  *
  * <pre>
  * {@literal @}TemplateExtension(matchName = "discounted")
@@ -107,18 +106,21 @@
     int DEFAULT_PRIORITY = 5;
 
     /**
+     * If {@link #ANY} is used then an additional string method parameter must be used to pass the actual property name.
      *
      * @return the name is used to match the property name
      */
     String matchName() default METHOD_NAME;
 
     /**
+     * Note that an additional string method parameter must be used to pass the actual property name.
      *
      * @return the list of names used to match the property name
      */
     String[] matchNames() default {};
 
     /**
+     * Note that an additional string method parameter must be used to pass the actual property name.
      *
      * @return the regex is used to match the property name
      */

independent-projects/qute/core/src/main/java/io/quarkus/qute/ValueResolvers.java

@@ -9,6 +9,7 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.NoSuchElementException;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.CompletionStage;
 import java.util.function.Function;
@@ -525,6 +526,34 @@ protected Object compute(Integer op1, Integer op2) {
 
     }
 
+    public static ValueResolver equalsResolver() {
+        return new EqualsResolver();
+    }
+
+    public static final class EqualsResolver implements ValueResolver {
+
+        public boolean appliesTo(EvalContext context) {
+            if (context.getParams().size() != 1) {
+                return false;
+            }
+            String name = context.getName();
+            return name.equals("==") || name.equals("eq") || name.equals("is");
+        }
+
+        @Override
+        public CompletionStage<Object> resolve(EvalContext context) {
+            Object base = context.getBase();
+            Expression otherExpr = context.getParams().get(0);
+            if (otherExpr.isLiteral()) {
+                Object literalValue = otherExpr.getLiteral();
+                return CompletedStage.of(Objects.equals(base, literalValue));
+            } else {
+                return context.evaluate(otherExpr).thenApply(other -> Objects.equals(base, other));
+            }
+        }
+
+    }
+
     static abstract class IntArithmeticResolver implements ValueResolver {
 
         public boolean appliesTo(EvalContext context) {

independent-projects/qute/core/src/test/java/io/quarkus/qute/EqualsResolverTest.java

@@ -0,0 +1,33 @@
+package io.quarkus.qute;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.function.Function;
+
+import org.junit.jupiter.api.Test;
+
+public class EqualsResolverTest {
+
+    @Test
+    public void tesEqualsResolver() {
+        Engine engine = Engine.builder().addDefaults().addValueResolver(new ReflectionValueResolver()).build();
+        assertEquals("false",
+                engine.parse("{name eq 'Andy'}").data("name", "Martin").render());
+        assertEquals("true",
+                engine.parse("{name is 'Andy'}").data("name", "Andy").render());
+        assertEquals("true",
+                engine.parse("{name == 'Andy'}").data("name", "Andy").render());
+        assertEquals("true",
+                engine.parse("{negate.apply(name is 'Andy')}").data("name", "David").data("negate", new NegateFun()).render());
+    }
+
+    public static class NegateFun implements Function<Boolean, Boolean> {
+
+        @Override
+        public Boolean apply(Boolean value) {
+            return !value;
+        }
+
+    }
+
+}