From 5ae4d25b3bc8f9cd5f7b3201b1b6f4609c91d437 Mon Sep 17 00:00:00 2001
From: Martin Kouba <mkouba@redhat.com>
Date: Mon, 28 Aug 2023 16:19:08 +0200
Subject: [PATCH] Qute: execute tag templates in isolation by default

- see https://github.com/quarkusio/quarkus/discussions/22285
---
 docs/src/main/asciidoc/qute-reference.adoc    |  8 ++--
 .../io/quarkus/qute/IncludeSectionHelper.java | 47 +++++++++----------
 .../io/quarkus/qute/UserTagSectionHelper.java | 20 ++++++--
 .../java/io/quarkus/qute/IncludeTest.java     | 14 ++++++
 .../java/io/quarkus/qute/UserTagTest.java     | 25 ++++++++--
 5 files changed, 76 insertions(+), 38 deletions(-)

diff --git a/docs/src/main/asciidoc/qute-reference.adoc b/docs/src/main/asciidoc/qute-reference.adoc
index fed88390ff54f..fd9eabea895cb 100644
--- a/docs/src/main/asciidoc/qute-reference.adoc
+++ b/docs/src/main/asciidoc/qute-reference.adoc
@@ -1143,10 +1143,10 @@ Then, we can call the tag like this:
 <1> `item` is resolved to an iteration element and can be referenced using the `it` key in the tag template.
 <2> Tag content injected using the `nested-content` key in the tag template.
 
-By default, the tag template can reference data from the parent context.
-For example, the tag above could use the following expression `{items.size}`.
-However, sometimes it might be useful to disable this behavior and execute the tag as an _isolated_ template, i.e. without access to the context of the template that calls the tag.
-In this case, just add `_isolated` or `_isolated=true` argument to the call site, e.g. `{#itemDetail item showImage=true _isolated /}`.
+By default, a tag template cannot reference the data from the parent context.
+Qute executes the tag as an _isolated_ template, i.e. without access to the context of the template that calls the tag.
+However, sometimes it might be useful to change the default behavior and disable the isolation.
+In this case, just add `_isolated=false` or `_unisolated` argument to the call site, for example `{#itemDetail item showImage=true _isolated=false /}` or `{#itemDetail item showImage=true _unisolated /}`.
 
 User tags can also make use of the template inheritance in the same way as regular `{#include}` sections do.
 
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/IncludeSectionHelper.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/IncludeSectionHelper.java
index d3e6489f497d5..d42298f4e3bb9 100644
--- a/independent-projects/qute/core/src/main/java/io/quarkus/qute/IncludeSectionHelper.java
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/IncludeSectionHelper.java
@@ -7,7 +7,6 @@
 import java.util.Map.Entry;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
-import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 import io.quarkus.qute.Template.Fragment;
@@ -117,6 +116,8 @@ protected boolean ignoreParameterInit(String key, String value) {
                     || key.equals(ISOLATED)
                     // {#include foo _isolated /}
                     || value.equals(ISOLATED)
+                    // {#include foo _unisolated /}
+                    || value.equals(UNISOLATED)
                     // {#include foo _ignoreFragments=true /}
                     || key.equals(IGNORE_FRAGMENTS)
                     // {#include foo _ignoreFragments /}
@@ -134,8 +135,9 @@ protected String getTemplateId(SectionInitContext context) {
 
         @Override
         protected IncludeSectionHelper newHelper(Supplier<Template> template, Map<String, Expression> params,
-                Map<String, SectionBlock> extendingBlocks, boolean isolated, SectionInitContext context) {
-            return new IncludeSectionHelper(template, extendingBlocks, params, isolated);
+                Map<String, SectionBlock> extendingBlocks, Boolean isolatedValue, SectionInitContext context) {
+            return new IncludeSectionHelper(template, extendingBlocks, params, isolatedValue != null ? isolatedValue
+                    : Boolean.parseBoolean(context.getParameterOrDefault(ISOLATED, Boolean.FALSE.toString())));
         }
 
     }
@@ -143,32 +145,24 @@ protected IncludeSectionHelper newHelper(Supplier<Template> template, Map<String
     static abstract class AbstractIncludeFactory<T extends SectionHelper> implements SectionHelperFactory<T> {
 
         static final String ISOLATED = "_isolated";
+        static final String UNISOLATED = "_unisolated";
         static final String IGNORE_FRAGMENTS = "_ignoreFragments";
-        static final String ISOLATED_DEFAULT_VALUE = "false";
 
         @Override
         public boolean treatUnknownSectionsAsBlocks() {
             return true;
         }
 
+        String isolatedDefaultValue() {
+            return Boolean.FALSE.toString();
+        }
+
         void addDefaultParams(ParametersInfo.Builder builder) {
             builder
-                    .addParameter(Parameter.builder(ISOLATED).defaultValue(ISOLATED_DEFAULT_VALUE).optional()
-                            .valuePredicate(new Predicate<String>() {
-
-                                @Override
-                                public boolean test(String v) {
-                                    return ISOLATED.equals(v);
-                                }
-                            }).build())
-                    .addParameter(Parameter.builder(IGNORE_FRAGMENTS).defaultValue(ISOLATED_DEFAULT_VALUE).optional()
-                            .valuePredicate(new Predicate<String>() {
-
-                                @Override
-                                public boolean test(String v) {
-                                    return IGNORE_FRAGMENTS.equals(v);
-                                }
-                            }).build())
+                    .addParameter(Parameter.builder(ISOLATED).defaultValue(isolatedDefaultValue()).optional()
+                            .valuePredicate(ISOLATED::equals).build())
+                    .addParameter(Parameter.builder(IGNORE_FRAGMENTS).defaultValue(Boolean.FALSE.toString()).optional()
+                            .valuePredicate(IGNORE_FRAGMENTS::equals).build())
                     .build();
         }
 
@@ -195,7 +189,7 @@ public Scope initializeBlock(Scope outerScope, BlockInfo block) {
         @Override
         public T initialize(SectionInitContext context) {
             boolean isEmpty = context.getBlocks().size() == 1 && context.getBlocks().get(0).isEmpty();
-            boolean isolatedValue = false;
+            Boolean isolatedValue = null;
             boolean ignoreFragments = false;
             Map<String, SectionBlock> extendingBlocks;
 
@@ -226,6 +220,9 @@ public T initialize(SectionInitContext context) {
                     if (value.equals(ISOLATED)) {
                         isolatedValue = true;
                         continue;
+                    } else if (value.equals(UNISOLATED)) {
+                        isolatedValue = false;
+                        continue;
                     }
                     if (value.equals(IGNORE_FRAGMENTS)) {
                         ignoreFragments = true;
@@ -242,7 +239,7 @@ public T initialize(SectionInitContext context) {
 
             //
             if (!ignoreFragments) {
-                ignoreFragments = Boolean.parseBoolean(context.getParameterOrDefault(IGNORE_FRAGMENTS, ISOLATED_DEFAULT_VALUE));
+                ignoreFragments = Boolean.parseBoolean(context.getParameterOrDefault(IGNORE_FRAGMENTS, "false"));
             }
             final String fragmentId = ignoreFragments ? null : getFragmentId(templateId, context);
             Supplier<Template> currentTemplate;
@@ -292,9 +289,7 @@ public Template get() {
                     return template;
                 }
             };
-
-            return newHelper(template, params, extendingBlocks, isolatedValue ? true
-                    : Boolean.parseBoolean(context.getParameterOrDefault(ISOLATED, ISOLATED_DEFAULT_VALUE)), context);
+            return newHelper(template, params, extendingBlocks, isolatedValue, context);
         }
 
         protected abstract String getTemplateId(SectionInitContext context);
@@ -342,7 +337,7 @@ protected boolean isSinglePart(String value) {
         protected abstract boolean ignoreParameterInit(String key, String value);
 
         protected abstract T newHelper(Supplier<Template> template, Map<String, Expression> params,
-                Map<String, SectionBlock> extendingBlocks, boolean isolated, SectionInitContext context);
+                Map<String, SectionBlock> extendingBlocks, Boolean isolatedValue, SectionInitContext context);
     }
 
     enum Code implements ErrorCode {
diff --git a/independent-projects/qute/core/src/main/java/io/quarkus/qute/UserTagSectionHelper.java b/independent-projects/qute/core/src/main/java/io/quarkus/qute/UserTagSectionHelper.java
index d4b9777ab4860..3d8529e53dd93 100644
--- a/independent-projects/qute/core/src/main/java/io/quarkus/qute/UserTagSectionHelper.java
+++ b/independent-projects/qute/core/src/main/java/io/quarkus/qute/UserTagSectionHelper.java
@@ -42,6 +42,8 @@ private boolean isNestedContent(Expression expr) {
     public static class Factory extends IncludeSectionHelper.AbstractIncludeFactory<UserTagSectionHelper> {
 
         private static final String IT = "it";
+        // Unlike regular includes user tags are isolated by default
+        private static final String ISOLATED_DEFAULT_VALUE = "true";
 
         private final String name;
         private final String templateId;
@@ -61,6 +63,11 @@ public List<String> getDefaultAliases() {
             return ImmutableList.of(name);
         }
 
+        @Override
+        String isolatedDefaultValue() {
+            return ISOLATED_DEFAULT_VALUE;
+        }
+
         @Override
         public ParametersInfo getParameters() {
             ParametersInfo.Builder builder = ParametersInfo.builder().addParameter(Parameter.builder(IT).defaultValue(IT));
@@ -71,9 +78,11 @@ public ParametersInfo getParameters() {
         @Override
         protected boolean ignoreParameterInit(String key, String value) {
             // {#myTag _isolated=true /}
-            return key.equals(IncludeSectionHelper.Factory.ISOLATED)
+            return key.equals(ISOLATED)
                     // {#myTag _isolated /}
-                    || value.equals(IncludeSectionHelper.Factory.ISOLATED)
+                    || value.equals(ISOLATED)
+                    // {#myTag _unisolated /}
+                    || value.equals(UNISOLATED)
                     // IT with default value, e.g. {#myTag foo=bar /}
                     || (key.equals(IT) && value.equals(IT));
         }
@@ -85,9 +94,12 @@ protected String getTemplateId(SectionInitContext context) {
 
         @Override
         protected UserTagSectionHelper newHelper(Supplier<Template> template, Map<String, Expression> params,
-                Map<String, SectionBlock> extendingBlocks, boolean isolated, SectionInitContext context) {
+                Map<String, SectionBlock> extendingBlocks, Boolean isolatedValue, SectionInitContext context) {
             boolean isNestedContentNeeded = !context.getBlock(SectionHelperFactory.MAIN_BLOCK_NAME).isEmpty();
-            return new UserTagSectionHelper(template, extendingBlocks, params, isolated, isNestedContentNeeded);
+            return new UserTagSectionHelper(template, extendingBlocks, params,
+                    isolatedValue != null ? isolatedValue
+                            : Boolean.parseBoolean(context.getParameterOrDefault(ISOLATED, ISOLATED_DEFAULT_VALUE)),
+                    isNestedContentNeeded);
         }
 
         @Override
diff --git a/independent-projects/qute/core/src/test/java/io/quarkus/qute/IncludeTest.java b/independent-projects/qute/core/src/test/java/io/quarkus/qute/IncludeTest.java
index e8b762996d2ad..316e046642fa9 100644
--- a/independent-projects/qute/core/src/test/java/io/quarkus/qute/IncludeTest.java
+++ b/independent-projects/qute/core/src/test/java/io/quarkus/qute/IncludeTest.java
@@ -237,4 +237,18 @@ public void testOptionalEndTag() {
                 engine.parse("{#include super}{#let foo=1} {foo}").render());
     }
 
+    @Test
+    public void testIsolation() {
+        Engine engine = Engine.builder()
+                .addDefaults()
+                .strictRendering(false)
+                .build();
+
+        Template foo = engine.parse("{name}");
+        engine.putTemplate("foo", foo);
+        assertEquals("Dorka", engine.parse("{#include foo /}").data("name", "Dorka").render());
+        assertEquals("Dorka", engine.parse("{#include foo _unisolated /}").data("name", "Dorka").render());
+        assertEquals("NOT_FOUND", engine.parse("{#include foo _isolated /}").data("name", "Dorka").render());
+    }
+
 }
diff --git a/independent-projects/qute/core/src/test/java/io/quarkus/qute/UserTagTest.java b/independent-projects/qute/core/src/test/java/io/quarkus/qute/UserTagTest.java
index 23a163190afc1..faf15ff71d50e 100644
--- a/independent-projects/qute/core/src/test/java/io/quarkus/qute/UserTagTest.java
+++ b/independent-projects/qute/core/src/test/java/io/quarkus/qute/UserTagTest.java
@@ -30,7 +30,8 @@ public void testUserTag() {
         assertEquals("nope",
                 engine.parse("{#each this}{#myTag showImage=false /}{/each}").render(Collections.singletonMap("order", order)));
         assertEquals("Herbert",
-                engine.parse("{#each this}{#myTag it showImage=true /}{/each}").render(Collections.singletonList(order)));
+                engine.parse("{#each this}{#myTag it showImage=true _isolated=false /}{/each}")
+                        .render(Collections.singletonList(order)));
     }
 
     @Test
@@ -45,7 +46,8 @@ public void testUserTagWithNestedContent() {
         Map<String, Object> order = new HashMap<>();
         order.put("name", "Herbert");
         assertEquals("<b>Herbert</b>",
-                engine.parse("{#myTag showImage=true}{order.name}{/}").render(Collections.singletonMap("order", order)));
+                engine.parse("{#myTag showImage=true _isolated=false}{order.name}{/}")
+                        .render(Collections.singletonMap("order", order)));
         assertEquals("nope", engine.parse("{#myTag}{order.name}{/}").render(Collections.singletonMap("order", order)));
         assertEquals("nope",
                 engine.parse("{#myTag showImage=false}{order.name}{/}").render(Collections.singletonMap("order", order)));
@@ -53,7 +55,7 @@ public void testUserTagWithNestedContent() {
                 engine.parse("{#each this}{#myTag showImage=false}{it.name}{/}{/each}")
                         .render(Collections.singletonMap("order", order)));
         assertEquals("<b>Herbert</b>",
-                engine.parse("{#each this}{#myTag showImage=true}{it.name}{/}{/each}")
+                engine.parse("{#each this}{#myTag showImage=true _isolated=false}{it.name}{/}{/each}")
                         .render(Collections.singletonList(order)));
     }
 
@@ -105,7 +107,7 @@ public void testEval() {
         engine.putTemplate("my-tag-id", tag);
 
         assertEquals("10 kg",
-                engine.parse("{#itemDetail itemId=1 myNestedContent=\"{item.quantity} {item.unit}\" /}")
+                engine.parse("{#itemDetail itemId=1 myNestedContent=\"{item.quantity} {item.unit}\" _isolated=false /}")
                         .data("items", Map.of(1, Map.of("quantity", 10, "unit", "kg"))).render());
     }
 
@@ -140,4 +142,19 @@ public void testInsertSections() {
         assertEquals("Baz!", engine.parse("{#myTag2}Baz!{/myTag2}").render());
     }
 
+    @Test
+    public void testIsolation() {
+        Engine engine = Engine.builder()
+                .addDefaults()
+                .addSectionHelper(new UserTagSectionHelper.Factory("myTag", "my-tag-id"))
+                .strictRendering(false)
+                .build();
+
+        Template tag = engine.parse("{name}");
+        engine.putTemplate("my-tag-id", tag);
+        assertEquals("NOT_FOUND", engine.parse("{#myTag /}").data("name", "Dorka").render());
+        assertEquals("Dorka", engine.parse("{#myTag _isolated=false /}").data("name", "Dorka").render());
+        assertEquals("Dorka", engine.parse("{#myTag _unisolated /}").data("name", "Dorka").render());
+    }
+
 }