Merge pull request #39 from linkdata/ui-primitive-helpers

UI primitive helpers

jaws.go

@@ -497,9 +497,17 @@ func (jw *Jaws) ServeWithTimeout(requestTimeout time.Duration) {
 	if maintenanceInterval < minInterval {
 		maintenanceInterval = minInterval
 	}
-	t := time.NewTicker(maintenanceInterval)
-	defer t.Stop()
+
 	subs := map[chan Message]*Request{}
+	t := time.NewTicker(maintenanceInterval)
+
+	defer func() {
+		t.Stop()
+		for ch, rq := range subs {
+			rq.cancel(nil)
+			close(ch)
+		}
+	}()
 
 	killSub := func(msgCh chan Message) {
 		if _, ok := subs[msgCh]; ok {

request.go

@@ -666,7 +666,6 @@ func (rq *Request) sendQueue(outboundMsgCh chan<- wsMsg) {
 
 	for i := range toSend {
 		select {
-		case <-rq.Jaws.doneCh:
 		case <-rq.Done():
 		case outboundMsgCh <- toSend[i]:
 		}

rlocker.go

@@ -0,0 +1,6 @@
+package jaws
+
+type RLocker interface {
+	RLock()
+	RUnlock()
+}

uibool.go

@@ -0,0 +1,31 @@
+package jaws
+
+import "sync"
+
+var _ BoolSetter = UiBool{}
+
+// UiBool implements BoolSetter given a sync.Locker (or RLocker) and a bool pointer.
+type UiBool struct {
+	L sync.Locker
+	P *bool
+}
+
+func (ui UiBool) JawsGetBool(e *Element) (val bool) {
+	if rl, ok := ui.L.(RLocker); ok {
+		rl.RLock()
+		val = *ui.P
+		rl.RUnlock()
+		return
+	}
+	ui.L.Lock()
+	val = *ui.P
+	ui.L.Unlock()
+	return
+}
+
+func (ui UiBool) JawsSetBool(e *Element, val bool) (err error) {
+	ui.L.Lock()
+	*ui.P = val
+	ui.L.Unlock()
+	return
+}

uibool_test.go

@@ -0,0 +1,28 @@
+package jaws
+
+import (
+	"sync"
+	"testing"
+)
+
+func TestUiBool(t *testing.T) {
+	var l sync.Mutex
+	var rl sync.RWMutex
+	var val bool
+
+	ui := UiBool{L: &l, P: &val}
+
+	if ui.JawsGetBool(nil) {
+		t.Fail()
+	}
+
+	if x := ui.JawsSetBool(nil, true); x != nil {
+		t.Error(x)
+	}
+
+	ui.L = &rl
+
+	if !ui.JawsGetBool(nil) {
+		t.Fail()
+	}
+}

uifloat.go

@@ -0,0 +1,33 @@
+package jaws
+
+import (
+	"sync"
+)
+
+var _ FloatSetter = UiFloat{}
+
+// UiFloat implements FloatSetter given a sync.Locker (or RLocker) and a float64 pointer.
+type UiFloat struct {
+	L sync.Locker
+	P *float64
+}
+
+func (ui UiFloat) JawsGetFloat(e *Element) (val float64) {
+	if rl, ok := ui.L.(RLocker); ok {
+		rl.RLock()
+		val = *ui.P
+		rl.RUnlock()
+		return
+	}
+	ui.L.Lock()
+	val = *ui.P
+	ui.L.Unlock()
+	return
+}
+
+func (ui UiFloat) JawsSetFloat(e *Element, val float64) (err error) {
+	ui.L.Lock()
+	*ui.P = val
+	ui.L.Unlock()
+	return
+}

uifloat_test.go

@@ -0,0 +1,28 @@
+package jaws
+
+import (
+	"sync"
+	"testing"
+)
+
+func TestUiFloat(t *testing.T) {
+	var l sync.Mutex
+	var rl sync.RWMutex
+	var val float64
+
+	ui := UiFloat{L: &l, P: &val}
+
+	if ui.JawsGetFloat(nil) != 0 {
+		t.Fail()
+	}
+
+	if x := ui.JawsSetFloat(nil, -1); x != nil {
+		t.Error(x)
+	}
+
+	ui.L = &rl
+
+	if ui.JawsGetFloat(nil) != -1 {
+		t.Fail()
+	}
+}

uistring.go

@@ -0,0 +1,40 @@
+package jaws
+
+import (
+	"html"
+	"html/template"
+	"sync"
+)
+
+var _ StringSetter = UiString{}
+
+// UiString implements StringSetter and HtmlGetter given a sync.Locker (or RLocker) and a string pointer.
+type UiString struct {
+	L sync.Locker
+	P *string
+}
+
+func (ui UiString) JawsGetString(e *Element) (val string) {
+	if rl, ok := ui.L.(RLocker); ok {
+		rl.RLock()
+		val = *ui.P
+		rl.RUnlock()
+		return
+	}
+	ui.L.Lock()
+	val = *ui.P
+	ui.L.Unlock()
+	return
+}
+
+func (ui UiString) JawsSetString(e *Element, val string) (err error) {
+	ui.L.Lock()
+	*ui.P = val
+	ui.L.Unlock()
+	return
+}
+
+func (ui UiString) JawsGetHtml(e *Element) (val template.HTML) {
+	val = template.HTML(html.EscapeString(ui.JawsGetString(e))) // #nosec G203
+	return
+}

uistring_test.go

@@ -0,0 +1,28 @@
+package jaws
+
+import (
+	"sync"
+	"testing"
+)
+
+func TestUiString(t *testing.T) {
+	var l sync.Mutex
+	var rl sync.RWMutex
+	var val string
+
+	ui := UiString{L: &l, P: &val}
+
+	if ui.JawsGetString(nil) != "" {
+		t.Fail()
+	}
+
+	if x := ui.JawsSetString(nil, "foo<"); x != nil {
+		t.Error(x)
+	}
+
+	ui.L = &rl
+
+	if ui.JawsGetHtml(nil) != "foo&lt;" {
+		t.Fail()
+	}
+}