From 5199c11e372d6c1af68d3b1b2c37e42b2027c1c3 Mon Sep 17 00:00:00 2001 From: Dave Syer Date: Tue, 21 Apr 2020 11:23:48 +0100 Subject: [PATCH 1/2] Fix Mustache to not ignore native fetcher Alter the logic of `MustacheEnvironmentCollector` so that the native fetcher is always consulted if it exists. When the context is a map (as it is in a web View for instance) you can't assume a non-null fetcher actually contains the property you are searching for. See gh-21060 --- .../MustacheEnvironmentCollector.java | 35 ++++++++++++++--- .../MustacheStandaloneIntegrationTests.java | 38 ++++++++++++++++++- 2 files changed, 67 insertions(+), 6 deletions(-) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheEnvironmentCollector.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheEnvironmentCollector.java index 0a58f4341d..1abe4e3a57 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheEnvironmentCollector.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheEnvironmentCollector.java @@ -19,6 +19,7 @@ package org.springframework.boot.autoconfigure.mustache; import com.samskivert.mustache.DefaultCollector; import com.samskivert.mustache.Mustache.Collector; import com.samskivert.mustache.Mustache.VariableFetcher; +import com.samskivert.mustache.Template; import org.springframework.context.EnvironmentAware; import org.springframework.core.env.ConfigurableEnvironment; @@ -35,8 +36,6 @@ public class MustacheEnvironmentCollector extends DefaultCollector implements En private ConfigurableEnvironment environment; - private final VariableFetcher propertyFetcher = new PropertyVariableFetcher(); - @Override public void setEnvironment(Environment environment) { this.environment = (ConfigurableEnvironment) environment; @@ -46,19 +45,45 @@ public class MustacheEnvironmentCollector extends DefaultCollector implements En public VariableFetcher createFetcher(Object ctx, String name) { VariableFetcher fetcher = super.createFetcher(ctx, name); if (fetcher != null) { - return fetcher; + return new PropertyVariableFetcher(fetcher); } if (this.environment.containsProperty(name)) { - return this.propertyFetcher; + return new PropertyVariableFetcher(); } return null; } private class PropertyVariableFetcher implements VariableFetcher { + private final VariableFetcher nativeFetcher; + + PropertyVariableFetcher() { + this.nativeFetcher = null; + } + + PropertyVariableFetcher(VariableFetcher nativeFetcher) { + this.nativeFetcher = nativeFetcher; + } + @Override public Object get(Object ctx, String name) { - return MustacheEnvironmentCollector.this.environment.getProperty(name); + Object result; + if (this.nativeFetcher != null) { + try { + result = this.nativeFetcher.get(ctx, name); + if (result != null && result != Template.NO_FETCHER_FOUND) { + return result; + } + } + catch (Exception ex) { + // fall through + } + } + result = MustacheEnvironmentCollector.this.environment.getProperty(name); + if (result == null) { + return Template.NO_FETCHER_FOUND; + } + return result; } } diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheStandaloneIntegrationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheStandaloneIntegrationTests.java index 85bf79322e..620fe0efb2 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheStandaloneIntegrationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheStandaloneIntegrationTests.java @@ -37,7 +37,7 @@ import static org.assertj.core.api.Assertions.assertThat; * @author Dave Syer */ @DirtiesContext -@SpringBootTest(webEnvironment = WebEnvironment.NONE, properties = { "env.FOO=There", "foo=World" }) +@SpringBootTest(webEnvironment = WebEnvironment.NONE, properties = { "env.FOO=There", "foo=World", "bar.name=Bar" }) class MustacheStandaloneIntegrationTests { @Autowired @@ -60,15 +60,51 @@ class MustacheStandaloneIntegrationTests { .isEqualTo("Hello: There"); } + @Test + void environmentCollectorCompoundKeyStandardMap() { + assertThat(this.compiler.standardsMode(true).compile("Hello: {{env.foo}}") + .execute(Collections.singletonMap("world", "World"))).isEqualTo("Hello: There"); + } + + @Test + void environmentCollectorCompoundKeyWithBean() { + assertThat(this.compiler.compile("Hello: {{foo.name}}") + .execute(Collections.singletonMap("foo", new Foo()))).isEqualTo("Hello: Foo"); + } + + @Test + void environmentCollectorCompoundKeyWithBeanPrefersEnvironment() { + assertThat(this.compiler.compile("Hello: {{bar.name}}") + .execute(Collections.singletonMap("bar", new Foo()))).isEqualTo("Hello: Bar"); + } + @Test void environmentCollectorSimpleKey() { assertThat(this.compiler.compile("Hello: {{foo}}").execute(new Object())).isEqualTo("Hello: World"); } + @Test + void environmentCollectorSimpleKeyMap() { + assertThat(this.compiler.compile("Hello: {{foo}}").execute(Collections.singletonMap("world", "Foo"))) + .isEqualTo("Hello: World"); + } + @Configuration(proxyBeanMethods = false) @Import({ MustacheAutoConfiguration.class, PropertyPlaceholderAutoConfiguration.class }) static class Application { } + + static class Foo { + private String name = "Foo"; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + } } From ddbecf62b3ed07422ab8863b12fd01b85c432180 Mon Sep 17 00:00:00 2001 From: Phillip Webb Date: Mon, 8 Jun 2020 11:06:01 -0700 Subject: [PATCH 2/2] Polish 'Fix Mustache to not ignore native fetcher' See gh-21060 --- .../MustacheEnvironmentCollector.java | 43 ++++++++++--------- .../MustacheStandaloneIntegrationTests.java | 18 ++++---- 2 files changed, 33 insertions(+), 28 deletions(-) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheEnvironmentCollector.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheEnvironmentCollector.java index 1abe4e3a57..c9d0cebfbd 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheEnvironmentCollector.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheEnvironmentCollector.java @@ -43,9 +43,9 @@ public class MustacheEnvironmentCollector extends DefaultCollector implements En @Override public VariableFetcher createFetcher(Object ctx, String name) { - VariableFetcher fetcher = super.createFetcher(ctx, name); - if (fetcher != null) { - return new PropertyVariableFetcher(fetcher); + VariableFetcher nativeFetcher = super.createFetcher(ctx, name); + if (nativeFetcher != null) { + return new PropertyVariableFetcher(nativeFetcher); } if (this.environment.containsProperty(name)) { return new PropertyVariableFetcher(); @@ -53,6 +53,9 @@ public class MustacheEnvironmentCollector extends DefaultCollector implements En return null; } + /** + * {@link VariableFetcher} that also checks the {@link Environment}. + */ private class PropertyVariableFetcher implements VariableFetcher { private final VariableFetcher nativeFetcher; @@ -61,29 +64,29 @@ public class MustacheEnvironmentCollector extends DefaultCollector implements En this.nativeFetcher = null; } - PropertyVariableFetcher(VariableFetcher nativeFetcher) { - this.nativeFetcher = nativeFetcher; + PropertyVariableFetcher(VariableFetcher delegate) { + this.nativeFetcher = delegate; } @Override public Object get(Object ctx, String name) { - Object result; - if (this.nativeFetcher != null) { - try { - result = this.nativeFetcher.get(ctx, name); - if (result != null && result != Template.NO_FETCHER_FOUND) { - return result; - } - } - catch (Exception ex) { - // fall through - } + Object result = getFromNativeFetcher(ctx, name); + result = (result != null) ? result : getFromEnvironment(name); + return (result != null) ? result : Template.NO_FETCHER_FOUND; + } + + private Object getFromNativeFetcher(Object ctx, String name) { + try { + Object result = (this.nativeFetcher != null) ? this.nativeFetcher.get(ctx, name) : null; + return (result != Template.NO_FETCHER_FOUND) ? result : null; } - result = MustacheEnvironmentCollector.this.environment.getProperty(name); - if (result == null) { - return Template.NO_FETCHER_FOUND; + catch (Exception ex) { + return null; } - return result; + } + + private Object getFromEnvironment(String name) { + return MustacheEnvironmentCollector.this.environment.getProperty(name); } } diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheStandaloneIntegrationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheStandaloneIntegrationTests.java index 620fe0efb2..7c1efa729c 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheStandaloneIntegrationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheStandaloneIntegrationTests.java @@ -68,14 +68,14 @@ class MustacheStandaloneIntegrationTests { @Test void environmentCollectorCompoundKeyWithBean() { - assertThat(this.compiler.compile("Hello: {{foo.name}}") - .execute(Collections.singletonMap("foo", new Foo()))).isEqualTo("Hello: Foo"); + assertThat(this.compiler.compile("Hello: {{foo.name}}").execute(Collections.singletonMap("foo", new Foo()))) + .isEqualTo("Hello: Foo"); } @Test void environmentCollectorCompoundKeyWithBeanPrefersEnvironment() { - assertThat(this.compiler.compile("Hello: {{bar.name}}") - .execute(Collections.singletonMap("bar", new Foo()))).isEqualTo("Hello: Bar"); + assertThat(this.compiler.compile("Hello: {{bar.name}}").execute(Collections.singletonMap("bar", new Foo()))) + .isEqualTo("Hello: Bar"); } @Test @@ -94,17 +94,19 @@ class MustacheStandaloneIntegrationTests { static class Application { } - + static class Foo { + private String name = "Foo"; - public String getName() { - return name; + String getName() { + return this.name; } - public void setName(String name) { + void setName(String name) { this.name = name; } + } }