handle duplicate elements in contents

Author: linkdata

ui/containerhelper.go

@@ -60,40 +60,42 @@ func (ui *ContainerHelper) RenderContainer(e *core.Element, w io.Writer, outerHT
 }
 
 func (ui *ContainerHelper) UpdateContainer(e *core.Element) {
-	var toRemove, toAppend []*core.Element
-	var orderData []core.Jid
+	var toAppend []*core.Element
 
-	oldMap := make(map[core.UI]*core.Element)
-	newMap := make(map[core.UI]struct{})
-	newContents := ui.Container.JawsContains(e)
-	for _, childUI := range newContents {
-		newMap[childUI] = struct{}{}
-	}
+	wantContents := ui.Container.JawsContains(e)
+	newOrder := make([]core.Jid, 0, len(wantContents))
 
 	ui.mu.Lock()
+	// build pool of reusable Elements keyed by UI, preserving duplicates
+	pool := make(map[core.UI][]*core.Element, len(ui.contents))
 	oldOrder := make([]core.Jid, len(ui.contents))
 	for i, elem := range ui.contents {
 		oldOrder[i] = elem.Jid()
-		oldMap[elem.Ui()] = elem
-		if _, ok := newMap[elem.Ui()]; !ok {
-			toRemove = append(toRemove, elem)
-		}
+		pool[elem.Ui()] = append(pool[elem.Ui()], elem)
 	}
+
+	// build new contents, reusing pooled Elements where possible
 	ui.contents = ui.contents[:0]
-	for _, childUI := range newContents {
-		elem := oldMap[childUI]
-		if elem == nil {
+	for _, childUI := range wantContents {
+		var elem *core.Element
+		if elems := pool[childUI]; len(elems) > 0 {
+			elem = elems[0]
+			pool[childUI] = elems[1:]
+		} else {
 			elem = e.Request.NewElement(childUI)
 			toAppend = append(toAppend, elem)
 		}
 		ui.contents = append(ui.contents, elem)
-		orderData = append(orderData, elem.Jid())
+		newOrder = append(newOrder, elem.Jid())
 	}
 	ui.mu.Unlock()
 
-	for _, elem := range toRemove {
-		e.Remove(elem.Jid().String())
-		e.Request.DeleteElement(elem)
+	// remove leftover Elements not present in new contents
+	for _, elems := range pool {
+		for _, elem := range elems {
+			e.Remove(elem.Jid().String())
+			e.Request.DeleteElement(elem)
+		}
 	}
 
 	for _, elem := range toAppend {
@@ -102,7 +104,7 @@ func (ui *ContainerHelper) UpdateContainer(e *core.Element) {
 		e.Append(template.HTML(sb.String())) // #nosec G203
 	}
 
-	if !slices.Equal(oldOrder, orderData) {
-		e.Order(orderData)
+	if !slices.Equal(oldOrder, newOrder) {
+		e.Order(newOrder)
 	}
 }

ui/containerhelper_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/linkdata/jaws/core"
+	"github.com/linkdata/jaws/jid"
 	"github.com/linkdata/jaws/what"
 )
 
@@ -61,6 +62,63 @@ func TestContainerHelperUpdateContainer(t *testing.T) {
 	}
 }
 
+func TestContainerHelperUpdateContainerDuplicates(t *testing.T) {
+	_, rq := newRequest(t)
+	span1 := NewSpan(testHTMLGetter("span1"))
+	span2 := NewSpan(testHTMLGetter("span2"))
+
+	// render with duplicate UI
+	tc := &testContainer{contents: []core.UI{span1, span2, span1}}
+	container := NewContainer("div", tc)
+	elem, _ := renderUI(t, rq, container)
+
+	if len(container.contents) != 3 {
+		t.Fatalf("want 3 contents got %d", len(container.contents))
+	}
+	// the two span1 Elements must have distinct Jids
+	jid0 := container.contents[0].Jid()
+	jid2 := container.contents[2].Jid()
+	if jid0 == jid2 {
+		t.Fatal("duplicate UI must produce distinct Jids")
+	}
+
+	// remove one duplicate, keep the other
+	tc.contents = []core.UI{span2, span1}
+	container.JawsUpdate(elem)
+	if len(container.contents) != 2 {
+		t.Fatalf("want 2 contents got %d", len(container.contents))
+	}
+	// one of the two span1 Jids should have been removed
+	kept := container.contents[1].Jid()
+	if kept != jid0 && kept != jid2 {
+		t.Fatalf("expected kept Jid to be one of the original span1 Jids")
+	}
+	var removedJid jid.Jid
+	if kept == jid0 {
+		removedJid = jid2
+	} else {
+		removedJid = jid0
+	}
+	if got := rq.GetElementByJid(removedJid); got != nil {
+		t.Fatal("expected surplus duplicate to be deleted from request")
+	}
+
+	// add more duplicates
+	tc.contents = []core.UI{span1, span2, span1, span2}
+	container.JawsUpdate(elem)
+	if len(container.contents) != 4 {
+		t.Fatalf("want 4 contents got %d", len(container.contents))
+	}
+	// all four must have distinct Jids
+	jids := make(map[jid.Jid]struct{}, 4)
+	for i, c := range container.contents {
+		if _, ok := jids[c.Jid()]; ok {
+			t.Fatalf("contents[%d] has duplicate Jid %v", i, c.Jid())
+		}
+		jids[c.Jid()] = struct{}{}
+	}
+}
+
 func TestContainerHelperRenderErrorPaths(t *testing.T) {
 	_, rq := newRequest(t)
 	renderErr := errors.New("render error")