wbgo => wbgong renaming

README.md

@@ -1 +1 @@
-wbgo interface to wbgo.so plugin
+wbgong interface to wbgo.so plugin

content_tracker.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 // ContentTracker used to track file contents
 type ContentTracker interface {

control.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 // ControlError is MQTT control error interface
 type ControlError interface {

conventions.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 const (
 	//

devicefilter.go

@@ -2,7 +2,7 @@
 // of devices/controls.
 // Device filters are used in DriverBackend to filter MQTT topics to subscribe
 
-package wbgo
+package wbgong
 
 // DeviceFilter is a device filter representation for Driver
 type DeviceFilter interface {

devices.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import (
 	"fmt"

dirwatcher.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import "time"
 

driver_frontend.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import (
 	"log"

errors.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import "errors"
 

events.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import "fmt"
 

funcs.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import (
 	"log"

go.mod

@@ -1,4 +1,4 @@
-module github.com/contactless/wbgo
+module github.com/contactless/wbgong
 
 go 1.12
 

init.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import (
 	"errors"

log.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import (
 	"io/ioutil"

mqtt.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import "log"
 

rpc.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 // MQTTRPCServer represents mqtt rpc server
 type MQTTRPCServer interface {

statsd.go

@@ -1,4 +1,4 @@
-package wbgo
+package wbgong
 
 import (
 	"log"

testutils/datafilefixture.go

@@ -20,7 +20,7 @@ type DataFileFixture struct {
 
 func NewDataFileFixture(t *testing.T) (f *DataFileFixture) {
 	if oldRmDataDir != nil {
-		// don't use wbgo.Warn here to avoid unneeded test failures
+		// don't use wbgong.Warn here to avoid unneeded test failures
 		log.Printf("SetupTempDir(): WARNING: using auto cleanup for previous NewDataFileFixture() " +
 			"[perhaps due to an unfinished fixture setup]")
 		oldRmDataDir()

testutils/fake_driver.go

@@ -4,16 +4,16 @@ import (
 	"testing"
 	"time"
 
-	"github.com/contactless/wbgo"
+	"github.com/contactless/wbgong"
 )
 
 // FakeDriverBackend is a dummy backend for model testing
 // Implements DriverBackend
 type FakeDriverBackend struct {
 	*Recorder
-	externalDeviceFactory wbgo.ExternalDeviceFactory
-	controlFactory        wbgo.ControlFactory
-	frontend              wbgo.DriverFrontend
+	externalDeviceFactory wbgong.ExternalDeviceFactory
+	controlFactory        wbgong.ControlFactory
+	frontend              wbgong.DriverFrontend
 }
 
 func NewFakeDriverBackend(t *testing.T) *FakeDriverBackend {
@@ -33,82 +33,82 @@ func (backend *FakeDriverBackend) Stop() {
 	backend.Rec("[FakeDriverBackend] Stop()")
 }
 
-func (backend *FakeDriverBackend) SetExternalDeviceFactory(e wbgo.ExternalDeviceFactory) {
+func (backend *FakeDriverBackend) SetExternalDeviceFactory(e wbgong.ExternalDeviceFactory) {
 	backend.externalDeviceFactory = e
 }
 
-func (backend *FakeDriverBackend) SetControlFactory(f wbgo.ControlFactory) {
+func (backend *FakeDriverBackend) SetControlFactory(f wbgong.ControlFactory) {
 	backend.controlFactory = f
 }
 
-func (backend *FakeDriverBackend) SetFrontend(f wbgo.DriverFrontend) {
+func (backend *FakeDriverBackend) SetFrontend(f wbgong.DriverFrontend) {
 	backend.frontend = f
 }
 
-func (backend *FakeDriverBackend) SetExternalDeviceFilter(e wbgo.DeviceFilter) {}
+func (backend *FakeDriverBackend) SetExternalDeviceFilter(e wbgong.DeviceFilter) {}
 
 func closedChan() <-chan error {
 	e := make(chan error, 1)
 	e <- nil
 	return e
 }
 
-func (backend *FakeDriverBackend) SetFilter(f wbgo.DeviceFilter) <-chan struct{} {
+func (backend *FakeDriverBackend) SetFilter(f wbgong.DeviceFilter) <-chan struct{} {
 	backend.Rec("[FakeDriverBackend] SetFilter(%T)", f)
 	c := make(chan struct{}, 1)
 	c <- struct{}{}
 	return c
 }
 
-func (backend *FakeDriverBackend) RemoveDevice(dev wbgo.LocalDevice) <-chan error {
+func (backend *FakeDriverBackend) RemoveDevice(dev wbgong.LocalDevice) <-chan error {
 	backend.Rec("[FakeDriverBackend] RemoveDevice(%s)", dev.GetId())
 	return closedChan()
 }
 
-func (backend *FakeDriverBackend) NewDevice(dev wbgo.LocalDevice) <-chan error {
+func (backend *FakeDriverBackend) NewDevice(dev wbgong.LocalDevice) <-chan error {
 	backend.Rec("[FakeDriverBackend] NewDevice(%s, meta %v)", dev.GetId(), dev.GetMeta())
 	return closedChan()
 }
 
-func (backend *FakeDriverBackend) NewDeviceControl(control wbgo.Control) <-chan error {
+func (backend *FakeDriverBackend) NewDeviceControl(control wbgong.Control) <-chan error {
 	backend.Rec("[FakeDriverBackend] NewDeviceControl(control %s/%s, value %s, meta %v)", control.GetDevice().GetId(), control.GetId(), control.GetRawValue(), control.GetMeta())
 	return closedChan()
 }
 
-func (backend *FakeDriverBackend) UpdateControlValue(control wbgo.Control, rawValue string) <-chan error {
+func (backend *FakeDriverBackend) UpdateControlValue(control wbgong.Control, rawValue string) <-chan error {
 	backend.Rec("[FakeDriverBackend] UpdateControlValue(control %s/%s, value %s)", control.GetDevice().GetId(), control.GetId(), rawValue)
 	return closedChan()
 }
 
-func (backend *FakeDriverBackend) SetOnValue(control wbgo.Control, rawValue string) <-chan error {
+func (backend *FakeDriverBackend) SetOnValue(control wbgong.Control, rawValue string) <-chan error {
 	backend.Rec("[FakeDriverBackend] SetOnValue(control %s/%s, value %s)", control.GetDevice().GetId(), control.GetId(), rawValue)
 	return closedChan()
 }
 
-func (backend *FakeDriverBackend) UpdateDeviceMeta(dev wbgo.LocalDevice, meta, value string) <-chan error {
+func (backend *FakeDriverBackend) UpdateDeviceMeta(dev wbgong.LocalDevice, meta, value string) <-chan error {
 	backend.Rec("[FakeDriverBackend] UpdateDeviceMeta(device %s, meta %s, value %s)", dev.GetId(), meta, value)
 	return closedChan()
 }
 
-func (backend *FakeDriverBackend) UpdateControlMeta(control wbgo.Control, meta, value string) <-chan error {
+func (backend *FakeDriverBackend) UpdateControlMeta(control wbgong.Control, meta, value string) <-chan error {
 	backend.Rec("[FakeDriverBackend] UpdateControlMeta(control %s/%s, meta %s, value %s)", control.GetDevice().GetId(), control.GetId(), meta, value)
 	return closedChan()
 }
 
-func (backend *FakeDriverBackend) RemoveControl(ctrl wbgo.Control) <-chan error {
+func (backend *FakeDriverBackend) RemoveControl(ctrl wbgong.Control) <-chan error {
 	backend.Rec("[FakeDriverBackend] RemoveControl(control %s/%s)", ctrl.GetDevice().GetId(), ctrl.GetId())
 	return closedChan()
 }
 
-func (backend *FakeDriverBackend) RemoveExternalDevice(dev wbgo.ExternalDevice) {
+func (backend *FakeDriverBackend) RemoveExternalDevice(dev wbgong.ExternalDevice) {
 	backend.Rec("[FakeDriverBackend] RemoveExternalDevice(%s)", dev.GetId())
 }
 
-func (backend *FakeDriverBackend) RemoveExternalControl(ctrl wbgo.Control) {
+func (backend *FakeDriverBackend) RemoveExternalControl(ctrl wbgong.Control) {
 	backend.Rec("[FakeDriverBackend] RemoveExternalControl(control %s/%s)", ctrl.GetDevice().GetId(), ctrl.GetId())
 }
 
-func (backend *FakeDriverBackend) PushEvent(event wbgo.DriverEvent) {
+func (backend *FakeDriverBackend) PushEvent(event wbgong.DriverEvent) {
 	backend.frontend.PushEvent(event)
 }
 
@@ -118,56 +118,56 @@ type FakeDriverFrontend struct {
 	*Recorder
 
 	id      string
-	backend wbgo.DriverBackend
+	backend wbgong.DriverBackend
 	doReown bool
 
-	Devices map[string]wbgo.Device
+	Devices map[string]wbgong.Device
 }
 
 func NewFakeDriverFrontend(id string, t *testing.T) *FakeDriverFrontend {
 	return &FakeDriverFrontend{
 		Recorder: NewRecorder(t),
 		id:       id,
-		Devices:  make(map[string]wbgo.Device),
+		Devices:  make(map[string]wbgong.Device),
 	}
 }
 
 func (f *FakeDriverFrontend) GetId() string {
 	return f.id
 }
 
-func (f *FakeDriverFrontend) SetFilter(fl wbgo.DeviceFilter) {
+func (f *FakeDriverFrontend) SetFilter(fl wbgong.DeviceFilter) {
 	<-f.backend.SetFilter(fl)
 }
 
 // dummy
-func (f *FakeDriverFrontend) SetLocalDeviceFactory(ff wbgo.LocalDeviceFactory) wbgo.LocalDeviceFactory {
+func (f *FakeDriverFrontend) SetLocalDeviceFactory(ff wbgong.LocalDeviceFactory) wbgong.LocalDeviceFactory {
 	return nil
 }
 
 // dummy
-func (f *FakeDriverFrontend) SetExternalDeviceFactory(ff wbgo.ExternalDeviceFactory) wbgo.ExternalDeviceFactory {
+func (f *FakeDriverFrontend) SetExternalDeviceFactory(ff wbgong.ExternalDeviceFactory) wbgong.ExternalDeviceFactory {
 	return nil
 }
 
 // dummy
-func (f *FakeDriverFrontend) SetControlFactory(ff wbgo.ControlFactory) wbgo.ControlFactory {
+func (f *FakeDriverFrontend) SetControlFactory(ff wbgong.ControlFactory) wbgong.ControlFactory {
 	return nil
 }
 
 // dummy
-func (f *FakeDriverFrontend) OnRetainReady(ff func(tx wbgo.DriverTx)) {}
+func (f *FakeDriverFrontend) OnRetainReady(ff func(tx wbgong.DriverTx)) {}
 
 // dummy
 func (f *FakeDriverFrontend) WaitForReady() {}
 
 // dummy
-func (f *FakeDriverFrontend) OnDriverEvent(ff func(e wbgo.DriverEvent)) wbgo.HandlerID {
+func (f *FakeDriverFrontend) OnDriverEvent(ff func(e wbgong.DriverEvent)) wbgong.HandlerID {
 	return 0
 }
 
 // dummy
-func (f *FakeDriverFrontend) RemoveOnDriverEventHandler(i wbgo.HandlerID) {}
+func (f *FakeDriverFrontend) RemoveOnDriverEventHandler(i wbgong.HandlerID) {}
 
 // dummy
 func (f *FakeDriverFrontend) LoopOnce(timeout time.Duration) bool {
@@ -184,44 +184,44 @@ func (f *FakeDriverFrontend) StopLoop() error {
 }
 
 // dummy
-func (f *FakeDriverFrontend) Access(thunk func(tx wbgo.DriverTx) error) error {
+func (f *FakeDriverFrontend) Access(thunk func(tx wbgong.DriverTx) error) error {
 	return nil
 }
 
 // dummy
-func (f *FakeDriverFrontend) AccessAsync(thunk func(tx wbgo.DriverTx) error) func() error {
+func (f *FakeDriverFrontend) AccessAsync(thunk func(tx wbgong.DriverTx) error) func() error {
 	return func() error {
 		return nil
 	}
 }
 
 // dummy
-func (f *FakeDriverFrontend) BeginTx() (wbgo.DriverTx, error) {
+func (f *FakeDriverFrontend) BeginTx() (wbgong.DriverTx, error) {
 	return nil, nil
 }
 
 // dummy
-func (f *FakeDriverFrontend) CreateUnsafeTx() wbgo.DeviceDriverTx {
+func (f *FakeDriverFrontend) CreateUnsafeTx() wbgong.DeviceDriverTx {
 	return nil
 }
 
 // dummy
 func (f *FakeDriverFrontend) Close() {}
 
 // Push driver event into processing queue
-func (f *FakeDriverFrontend) PushEvent(event wbgo.DriverEvent) {
+func (f *FakeDriverFrontend) PushEvent(event wbgong.DriverEvent) {
 	f.Rec("[FakeDriverFrontend] Received event %v", event)
 
 	switch e := event.(type) {
-	case wbgo.NewExternalDeviceEvent:
+	case wbgong.NewExternalDeviceEvent:
 		f.Devices[e.Device.GetId()] = e.Device
-	case wbgo.NewExternalDeviceControlEvent:
+	case wbgong.NewExternalDeviceControlEvent:
 		e.Device.AddControl(e.Control)
 	}
 }
 
 // Connect backend
-func (f *FakeDriverFrontend) SetBackend(b wbgo.DriverBackend) {
+func (f *FakeDriverFrontend) SetBackend(b wbgong.DriverBackend) {
 	f.backend = b
 }