Golangci: Add ci config and fixed linter issues (#54)

.golangci.yml

@@ -0,0 +1,75 @@
+run:
+tests: false
+skip-dirs:
+  - examples
+  - vendor
+
+linters:
+  enable:
+    - bodyclose
+    - deadcode
+    - depguard
+    - dogsled
+    - dupl
+    - errcheck
+    - exhaustive
+    - funlen
+    - gochecknoinits
+    - goconst
+    - gocritic
+    - gocyclo
+    - gofmt
+    - goimports
+    - golint
+    - gomnd
+    - goprintffuncname
+    - gosec
+    - gosimple
+    - govet
+    - ineffassign
+    - interfacer
+    - lll
+    - misspell
+    - nakedret
+    - noctx
+    - nolintlint
+    - rowserrcheck
+    - scopelint
+    - staticcheck
+    - structcheck
+    - stylecheck
+    - typecheck
+    - unconvert
+    - unparam
+    - unused
+    - varcheck
+    - whitespace
+    - asciicheck
+    - gochecknoglobals
+    - gocognit
+    - godot
+    - godox
+    - goerr113
+    - maligned
+    - nestif
+    - prealloc
+    - testpackage
+    - wsl
+
+linters-settings:
+  # see all options at https://github.com/bombsimon/wsl/blob/master/doc/configuration.md
+  # Even the default values have been copied here to give us control and fine tunning on them
+  wsl:
+    strict-append: false
+    allow-assign-and-call: true
+    allow-assign-and-anything: false
+    allow-multiline-assign: true
+    force-case-trailing-whitespace: 0
+    allow-cuddle-declarations: false
+    allow-case-trailing-whitespace: false
+    allow-trailing-comment: false
+    enforce-err-cuddling: false
+
+issues:
+  exclude:
+    - '^singleCaseSwitch'

Makefile

@@ -14,6 +14,12 @@ fmt:
 vet:
 	go vet $(ALL_PACKAGES)
 
+goimports:
+	goimports -w $(shell find . -type f -name '*.go' -not -path "./vendor/*")
+
+gofmts:
+	gofmt -s -w  $(shell find . -type f -name '*.go' -not -path "./vendor/*")
+
 lint:
 	@for p in $(ALL_PACKAGES); do \
 		echo "==> Linting $$p"; \

bus/bus.go

@@ -6,14 +6,14 @@ import (
 	"sync"
 )
 
-//The type of the function's first and only argument
-//declares the msg to listen for.
+// The type of the function's first and only argument.
+// declares the msg to listen for.
 type HandlerFunc interface{}
 
 type Msg interface{}
 
-//It is a simple but powerful publish-subscribe event system. It requires object to
-//register themselves with the event bus to receive events.
+// It is a simple but powerful publish-subscribe event system. It requires object to
+// register themselves with the event bus to receive events.
 type Bus interface {
 	Dispatch(msg Msg) error
 	AddHandler(handler HandlerFunc) error
@@ -34,14 +34,14 @@ func New() Bus {
 	}
 }
 
-//Dispatch sends an msg to registered handler that were declared
-//to accept values of a msg
+// Dispatch sends an msg to registered handler that were declared
+// to accept values of a msg
 func (b *InProcBus) Dispatch(msg Msg) error {
 	nameOfMsg := reflect.TypeOf(msg)
 
 	handler, ok := b.handlers[nameOfMsg.String()]
 	if !ok {
-		return fmt.Errorf("handler not found for %s", nameOfMsg)
+		return &HandlerNotFoundError{Name: nameOfMsg.Name()}
 	}
 
 	params := make([]reflect.Value, 0, 1)
@@ -55,8 +55,8 @@ func (b *InProcBus) Dispatch(msg Msg) error {
 	return nil
 }
 
-//Publish sends an msg to all registered listeners that were declared
-//to accept values of a msg
+// Publish sends an msg to all registered listeners that were declared
+// to accept values of a msg
 func (b *InProcBus) Publish(msg Msg) error {
 	nameOfMsg := reflect.TypeOf(msg)
 	listeners := b.listeners[nameOfMsg.String()]
@@ -74,8 +74,8 @@ func (b *InProcBus) Publish(msg Msg) error {
 	return nil
 }
 
-//AddHandler registers a handler function that will be called when a matching
-//msg is dispatched.
+// AddHandler registers a handler function that will be called when a matching
+// msg is dispatched.
 func (b *InProcBus) AddHandler(handler HandlerFunc) error {
 	b.Mutex.Lock()
 	defer b.Mutex.Unlock()
@@ -85,15 +85,15 @@ func (b *InProcBus) AddHandler(handler HandlerFunc) error {
 
 	typeOfMsg := handlerType.In(0)
 	if _, ok := b.handlers[typeOfMsg.String()]; ok {
-		return fmt.Errorf("handler exists for %s", typeOfMsg)
+		return &OverwriteHandlerError{Name: typeOfMsg.Name()}
 	}
 
 	b.handlers[typeOfMsg.String()] = reflect.ValueOf(handler)
 	return nil
 }
 
-//AddListener registers a listener function that will be called when a matching
-//msg is dispatched.
+// AddListener registers a listener function that will be called when a matching
+// msg is dispatched.
 func (b *InProcBus) AddEventListener(handler HandlerFunc) {
 	b.Mutex.Lock()
 	defer b.Mutex.Unlock()
@@ -109,7 +109,7 @@ func (b *InProcBus) AddEventListener(handler HandlerFunc) {
 	b.listeners[typOfMsg.String()] = append(b.listeners[typOfMsg.String()], reflect.ValueOf(handler))
 }
 
-//panic if conditions not met (this is a programming error)
+// panic if conditions not met (this is a programming error)
 func validateHandlerFunc(handlerType reflect.Type) {
 	switch {
 	case handlerType.Kind() != reflect.Func:
@@ -121,10 +121,22 @@ func validateHandlerFunc(handlerType reflect.Type) {
 	}
 }
 
-//BadFuncError is raised via panic() when AddEventListener or AddHandler is called with an
-//invalid listener function.
+// BadFuncError is raised via panic() when AddEventListener or AddHandler is called with an
+// invalid listener function.
 type BadFuncError string
 
 func (bhf BadFuncError) Error() string {
 	return fmt.Sprintf("bad handler func: %s", string(bhf))
 }
+
+type HandlerNotFoundError struct {
+	Name string
+}
+
+func (e *HandlerNotFoundError) Error() string { return e.Name + ": not found" }
+
+type OverwriteHandlerError struct {
+	Name string
+}
+
+func (e *OverwriteHandlerError) Error() string { return e.Name + ": handler exists" }

bus/bus_test.go

@@ -3,8 +3,9 @@ package bus_test
 import (
 	"errors"
 	"fmt"
-	"github.com/donutloop/toolkit/bus"
 	"testing"
+
+	"github.com/donutloop/toolkit/bus"
 )
 
 type msg struct {
@@ -15,27 +16,32 @@ type msg struct {
 func TestHandlerReturnsError(t *testing.T) {
 	b := bus.New()
 
-	b.AddHandler(func(m *msg) error {
+	err := b.AddHandler(func(m *msg) error {
 		return errors.New("handler error")
 	})
+	if err != nil {
+		t.Fatal(err)
+	}
 
-	err := b.Dispatch(new(msg))
+	err = b.Dispatch(new(msg))
 	if err == nil {
-		t.Fatalf("dispatch msg failed (%s)", err.Error())
+		t.Fatalf("dispatch msg failed (%v)", err)
 	}
 }
 
 func TestHandlerReturn(t *testing.T) {
 	b := bus.New()
 
-	b.AddHandler(func(m *msg) error {
+	err := b.AddHandler(func(m *msg) error {
 		m.body = "Hello, world!"
 		return nil
 	})
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	msg := new(msg)
-	err := b.Dispatch(msg)
-
+	err = b.Dispatch(msg)
 	if err != nil {
 		t.Fatalf("dispatch msg failed (%s)", err.Error())
 	}
@@ -80,9 +86,12 @@ func TestAddHandlerBadFunc(t *testing.T) {
 	}()
 
 	b := bus.New()
-	b.AddHandler(func(m *msg, s string) error {
+	err := b.AddHandler(func(m *msg, s string) error {
 		return nil
 	})
+	if err != nil {
+		t.Fatal(err)
+	}
 }
 
 func TestAddListenerBadFunc(t *testing.T) {
@@ -103,43 +112,43 @@ func TestAddListenerBadFunc(t *testing.T) {
 
 func BenchmarkHandlerRun(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		bus := bus.New()
+		bs := bus.New()
 
-		bus.AddHandler(func(m *msg) error {
+		bs.AddHandler(func(m *msg) error {
 			return nil
 		})
 
-		if err := bus.Dispatch(new(msg)); err != nil {
+		if err := bs.Dispatch(new(msg)); err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
 func BenchmarkListenerRun(b *testing.B) {
 	for n := 0; n < b.N; n++ {
-		bus := bus.New()
+		bs := bus.New()
 
-		bus.AddEventListener(func(m *msg) error {
+		bs.AddEventListener(func(m *msg) error {
 			return nil
 		})
 
-		bus.AddEventListener(func(m *msg) error {
+		bs.AddEventListener(func(m *msg) error {
 			return nil
 		})
 
-		bus.AddEventListener(func(m *msg) error {
+		bs.AddEventListener(func(m *msg) error {
 			return nil
 		})
 
-		bus.AddEventListener(func(m *msg) error {
+		bs.AddEventListener(func(m *msg) error {
 			return nil
 		})
 
-		bus.AddEventListener(func(m *msg) error {
+		bs.AddEventListener(func(m *msg) error {
 			return nil
 		})
 
-		if err := bus.Publish(new(msg)); err != nil {
+		if err := bs.Publish(new(msg)); err != nil {
 			b.Fatal(err)
 		}
 	}

bus/doc_test.go

@@ -2,14 +2,15 @@ package bus_test
 
 import (
 	"fmt"
+
 	"github.com/donutloop/toolkit/bus"
 )
 
-// Creates a bus and adds a listener to a message afterward it publishes a new message
-func ExampleBusListener() {
+// Creates a bus and adds a listener to a message afterward it publishes a new message.
+func ExampleInProcBus_AddEventListener() {
 
 	type msg struct {
-		Id   int64
+		ID   int64
 		body string
 	}
 
@@ -21,29 +22,34 @@ func ExampleBusListener() {
 	})
 
 	if err := b.Publish(new(msg)); err != nil {
-		fmt.Println(fmt.Sprintf("bus: %v", err))
+		fmt.Printf("error: (%v) \n", err)
 	}
 
 	// Output: db insert listener
 }
 
-// Creates a bus and adds a handler for a message afterward it dispatch a new message
-func ExampleBusHandler() {
+// Creates a bus and adds a handler for a message afterward it dispatch a new message.
+func ExampleInProcBus_AddHandler() {
 
 	type msg struct {
-		Id   int64
+		ID   int64
 		body string
 	}
 
 	b := bus.New()
 
-	b.AddHandler(func(m *msg) error {
+	err := b.AddHandler(func(m *msg) error {
 		fmt.Println("db insert listener")
 		return nil
 	})
 
+	if err != nil {
+		fmt.Printf("error: (%v) \n", err)
+		return
+	}
+
 	if err := b.Dispatch(new(msg)); err != nil {
-		fmt.Println(fmt.Sprintf("bus: %v", err))
+		fmt.Printf("error: (%v) \n", err)
 	}
 
 	// Output: db insert listener

cmd/xcode/main.go

@@ -3,11 +3,12 @@ package main
 import (
 	"flag"
 	"fmt"
-	"github.com/donutloop/toolkit/internal/ast"
 	"io/ioutil"
 	"log"
 	"os"
 	"text/tabwriter"
+
+	"github.com/donutloop/toolkit/internal/ast"
 )
 
 func main() {