Split apart deferrable range and deferrable value

internal/app/index.go

@@ -8,7 +8,7 @@ import (
 )
 
 type model struct {
-	Message deferrable.Defer[chan []string]
+	Message deferrable.Value[[]string]
 }
 
 func Index(addArtificialDelay bool) http.HandlerFunc {
@@ -27,6 +27,6 @@ func Index(addArtificialDelay bool) http.HandlerFunc {
 			close(data)
 		}()
 
-		_ = websupport.Render(w, Resources, "index", model{Message: deferrable.New(w, data)})
+		_ = websupport.Render(w, Resources, "index", model{Message: deferrable.NewValue(w, data)})
 	}
 }

internal/app/resources/templates/index.gohtml

@@ -19,17 +19,16 @@
             </slot>
         </section>
     </template>
-    {{ range $items := .Message.Value }}
-        <div slot="content">
-            <h2>
-                Success!
-            </h2>
+    {{ $items := .Message.Get }}
+    <div slot="content">
+        <h2>
+            Success!
+        </h2>
 
-            <ul class="bulleted">
-                {{range $item := $items}}
-                    <li>{{$item}}</li>
-                {{end}}
-            </ul>
-        </div>
-    {{ end }}
+        <ul class="bulleted">
+            {{range $item := $items}}
+                <li>{{$item}}</li>
+            {{end}}
+        </ul>
+    </div>
 {{- end}}

pkg/deferrable/flush.go

@@ -0,0 +1,7 @@
+package deferrable
+
+import "net/http"
+
+func Flush(w http.ResponseWriter) error {
+	return http.NewResponseController(w).Flush()
+}

pkg/deferrable/range.go

@@ -0,0 +1,31 @@
+package deferrable
+
+import "net/http"
+
+type Range[T any] struct {
+	writer  http.ResponseWriter
+	channel chan T
+}
+
+func NewRange[T any](writer http.ResponseWriter, channel chan T) Range[T] {
+	return Range[T]{
+		writer:  writer,
+		channel: channel,
+	}
+}
+
+func (d Range[T]) Get() chan T {
+	_ = Flush(d.writer)
+	flushChannel := make(chan T)
+
+	go func() {
+		for val := range d.channel {
+			_ = Flush(d.writer)
+			flushChannel <- val
+		}
+		_ = Flush(d.writer)
+		close(flushChannel)
+	}()
+
+	return flushChannel
+}

pkg/deferrable/range_test.go

@@ -0,0 +1,26 @@
+package deferrable_test
+
+import (
+	"github.com/initialcapacity/go-streaming/pkg/deferrable"
+	"github.com/initialcapacity/go-streaming/pkg/deferrable/test"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestRange(t *testing.T) {
+	writer := deferrable_test.ResponseWriterSpy{}
+	channel := make(chan string)
+	defer close(channel)
+
+	go func() {
+		channel <- "pickles"
+		channel <- "chicken"
+	}()
+
+	values := deferrable.NewRange(&writer, channel).Get()
+
+	assert.Equal(t, uint64(1), writer.FlushCalls.Load())
+	assert.Equal(t, "pickles", <-values)
+	assert.Equal(t, "chicken", <-values)
+	assert.Equal(t, uint64(3), writer.FlushCalls.Load())
+}

pkg/deferrable/test/response_writer_spy.go

@@ -0,0 +1,25 @@
+package deferrable_test
+
+import (
+	"net/http"
+	"sync/atomic"
+)
+
+type ResponseWriterSpy struct {
+	FlushCalls atomic.Uint64
+}
+
+func (w *ResponseWriterSpy) Header() http.Header {
+	return map[string][]string{}
+}
+
+func (w *ResponseWriterSpy) Write([]byte) (int, error) {
+	return 0, nil
+}
+
+func (w *ResponseWriterSpy) WriteHeader(_ int) {
+}
+
+func (w *ResponseWriterSpy) Flush() {
+	w.FlushCalls.Add(1)
+}

pkg/deferrable/value.go

@@ -0,0 +1,20 @@
+package deferrable
+
+import "net/http"
+
+type Value[T any] struct {
+	writer  http.ResponseWriter
+	channel chan T
+}
+
+func NewValue[T any](writer http.ResponseWriter, channel chan T) Value[T] {
+	return Value[T]{
+		writer:  writer,
+		channel: channel,
+	}
+}
+
+func (d Value[T]) Get() T {
+	_ = Flush(d.writer)
+	return <-d.channel
+}

pkg/deferrable/value_test.go

@@ -0,0 +1,23 @@
+package deferrable_test
+
+import (
+	"github.com/initialcapacity/go-streaming/pkg/deferrable"
+	"github.com/initialcapacity/go-streaming/pkg/deferrable/test"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestChannel(t *testing.T) {
+	writer := deferrable_test.ResponseWriterSpy{}
+	channel := make(chan string)
+	defer close(channel)
+
+	go func() {
+		channel <- "pickles"
+	}()
+
+	value := deferrable.NewValue(&writer, channel).Get()
+
+	assert.Equal(t, "pickles", value)
+	assert.Equal(t, uint64(1), writer.FlushCalls.Load())
+}