Add reactive progressive rendering features to MustacheView

.gitignore

@@ -10,6 +10,7 @@
 .DS_Store
 .classpath
 .factorypath
+.attach_pid*
 .gradle
 .idea
 .metadata

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mustache/MustacheReactiveWebConfiguration.java

@@ -38,6 +38,7 @@ public MustacheViewResolver mustacheViewResolver(Compiler mustacheCompiler,
 		resolver.setPrefix(mustache.getPrefix());
 		resolver.setSuffix(mustache.getSuffix());
 		resolver.setViewNames(mustache.getViewNames());
+		resolver.setCache(mustache.isCache());
 		resolver.setRequestContextAttribute(mustache.getRequestContextAttribute());
 		resolver.setCharset(mustache.getCharsetName());
 		resolver.setOrder(Ordered.LOWEST_PRECEDENCE - 10);

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/mustache/MustacheAutoConfigurationReactiveIntegrationTests.java

@@ -16,10 +16,13 @@
 
 package org.springframework.boot.autoconfigure.mustache;
 
+import java.time.Duration;
 import java.util.Date;
 
 import com.samskivert.mustache.Mustache;
+import org.hamcrest.Matchers;
 import org.junit.jupiter.api.Test;
+import reactor.core.publisher.Flux;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.SpringApplication;
@@ -35,6 +38,7 @@
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
+import org.springframework.http.MediaType;
 import org.springframework.stereotype.Controller;
 import org.springframework.test.web.reactive.server.WebTestClient;
 import org.springframework.ui.Model;
@@ -46,7 +50,7 @@
  * Integration Tests for {@link MustacheAutoConfiguration}, {@link MustacheViewResolver}
  * and {@link MustacheView}.
  *
- * @author Brian Clozel
+ * @author Brian Clozel, Dave Syer
  */
 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT,
 		properties = "spring.main.web-application-type=reactive")
@@ -69,6 +73,14 @@ public void testPartialPage() {
 		assertThat(result).contains("Hello App").contains("Hello World");
 	}
 
+	@Test
+	public void testSse() {
+		this.client.get().uri("/sse").exchange() //
+				.expectBody(String.class).value(Matchers.containsString("event: message"))
+				.value(Matchers.containsString("\ndata: <span>Hello</span>"))
+				.value(Matchers.containsString("World")).value(Matchers.endsWith("\n\n"));
+	}
+
 	@Configuration(proxyBeanMethods = false)
 	@Import({ ReactiveWebServerFactoryAutoConfiguration.class,
 			WebFluxAutoConfiguration.class, HttpHandlerAutoConfiguration.class,
@@ -92,6 +104,16 @@ public String layout(Model model) {
 			return "partial";
 		}
 
+		@RequestMapping(path = "/sse", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+		public String sse(Model model) {
+			model.addAttribute("time", new Date());
+			model.addAttribute("async:message",
+					Flux.just("<span>Hello</span>", "<span>World</span>")
+							.delayElements(Duration.ofMillis(10)));
+			model.addAttribute("title", "Hello App");
+			return "sse";
+		}
+
 		@Bean
 		public MustacheViewResolver viewResolver() {
 			Mustache.Compiler compiler = Mustache.compiler().withLoader(

spring-boot-project/spring-boot-autoconfigure/src/test/resources/mustache-templates/sse.html

@@ -0,0 +1,7 @@
+{{#async:message}}
+event: message
+{{#sse:data}}
+<h2>Title</h2>
+{{{.}}}
+{{/sse:data}}
+{{/async:message}}

spring-boot-project/spring-boot-docs/src/main/asciidoc/spring-boot-features.adoc

@@ -3032,6 +3032,54 @@ Spring Boot includes auto-configuration support for the following templating eng
 When you use one of these templating engines with the default configuration, your
 templates are picked up automatically from `src/main/resources/templates`.
 
+==== Mustache Views
+
+There are some special features of the `MustacheView` that make it suitable for handling the rendering of reactive elements. Most browsers will start to show content before the HTML tags are closed, so you can drip feed a list or a table into the view as the content becomes available.
+
+===== Progressive Rendering
+
+A model element of type `Publisher` will be left in the model (instead of expanding it before the view is rendered), if its name starts with "async:". The `View` is then rendered and flushed to the HTTP response as soon as each element is published. Browsers are really good at rendering partially complete HTML, so the flux elements will most likely be visible to the user as soon as they are available. This is useful for rendering the "main" content of a page if it is a list or a table, for instance.
+
+===== Sserver Sent Event (SSE) Support
+
+To render a `View` with content type `text/event-stream` you need a model element of type `Publisher`, and also a template that includes that element (probably starts and ends with it). There is a convenience Lambda (`ssedata`) added to the model for you that prepends every line with `data:` - you can use it if you wish to simplify the rendering of the data elements. Two new lines are added after each item in `{{#sse:data}}`. E.g. with an element called `async:events` of type `Flux<Event>`:
+
+```
+{{#async:events}}
+event: message
+id: {{id}}
+{{#sse:data}}
+<div>
+  <span>Name: {{name}}<span>
+  <span>Value: {{value}}<span>
+</div>
+{{/sse:data}}
+{{/async:events}}
+```
+
+the output will be
+
+```
+event: message
+id: 0
+data: <div>
+data:   <span>Name: foo<span>
+data:   <span>Value: bar<span>
+data: </div>
+
+
+event: message
+id: 1
+data: <div>
+data:   <span>Name: spam<span>
+data:   <span>Value: bucket<span>
+data: </div>
+
+
+... etc.
+```
+
+assuming the `Event` object has fields `id`, `name`, `value`.
 
 
 [[boot-features-webflux-error-handling]]

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/web/reactive/result/view/FluxWriter.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2019-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.web.reactive.result.view;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.core.io.buffer.DataBuffer;
+import org.springframework.core.io.buffer.DataBufferFactory;
+
+/**
+ * A {@link Writer} that can write a {@link Flux} (or {@link Publisher}) to a data buffer.
+ * Used to render progressive output in a {@link MustacheView}.
+ *
+ * @author Dave Syer
+ */
+class FluxWriter extends Writer {
+
+	private final DataBufferFactory factory;
+
+	private final Charset charset;
+
+	private List<Object> accumulated = new ArrayList<>();
+
+	FluxWriter(DataBufferFactory factory, Charset charset) {
+		this.factory = factory;
+		this.charset = charset;
+	}
+
+	@SuppressWarnings("unchecked")
+	public Flux<? extends Publisher<? extends DataBuffer>> getBuffers() {
+		Flux<String> buffers = Flux.empty();
+		List<String> chunks = new ArrayList<>();
+		for (Object thing : this.accumulated) {
+			if (thing instanceof Publisher) {
+				buffers = concatValues(chunks, buffers);
+				buffers = buffers.concatWith((Publisher<String>) thing);
+			}
+			else {
+				chunks.add((String) thing);
+			}
+		}
+		buffers = concatValues(chunks, buffers);
+		return buffers.map((string) -> Mono.fromCallable(
+				() -> this.factory.allocateBuffer().write(string, this.charset)));
+	}
+
+	private Flux<String> concatValues(List<String> chunks, Flux<String> buffers) {
+		if (!chunks.isEmpty()) {
+			buffers = buffers.concatWithValues(chunks.toArray(new String[0]));
+			chunks.clear();
+		}
+		return buffers;
+	}
+
+	@Override
+	public void write(char[] cbuf, int off, int len) throws IOException {
+		this.accumulated.add(new String(cbuf, off, len));
+	}
+
+	@Override
+	public void flush() throws IOException {
+	}
+
+	@Override
+	public void close() throws IOException {
+	}
+
+	public void release() {
+		// TODO: maybe implement this and call it on error
+	}
+
+	public void write(Object thing) {
+		this.accumulated.add(thing);
+	}
+
+}