fix: use error's marshaler, circular ref in Handler, lint issues (#28)

Author: abemedia

.github/workflows/test.yml

@@ -64,10 +64,4 @@ jobs:
           key: golangci-lint.cache-${{ hashFiles('**/go.sum') }}
           restore-keys: golangci-lint.cache-
 
-      - run: go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.44.2
-      - run: golangci-lint run
-
-  # Not supported with Go 1.18
-  #     - uses: golangci/golangci-lint-action@v3
-  #       with:
-  #         version: v1.44
+      - uses: golangci/golangci-lint-action@v3

.golangci.yml

@@ -1,63 +1,62 @@
 linters:
   enable-all: true
   disable:
+    - deadcode # deprecated
     - exhaustive
     - exhaustivestruct
+    - exhaustruct
     - forcetypeassert
     - funlen
     - gochecknoinits
     - gochecknoglobals
-    - gci
     - godox
     - golint # deprecated
     - gomnd
-    - ifshort # false positives
+    - ifshort # false positives - deprecated
     - interfacer # deprecated
     - ireturn
     - maligned # deprecated
+    - nosnakecase # deprecated
     - nlreturn
     - paralleltest
     - scopelint # deprecated
+    - structcheck # deprecated
     - testpackage
     - varnamelen
+    - varcheck # deprecated
     - wrapcheck
-    # no Go 1.18 support
-    - bodyclose
-    - contextcheck
-    - gocritic
-    - gosimple
-    - govet
-    - nilerr
-    - noctx
-    - rowserrcheck
-    - sqlclosecheck
-    - staticcheck
-    - structcheck
-    - stylecheck
-    - tparallel
-    - typecheck # false positives
-    - unparam
-    - unused
-    - wastedassign
+    - wsl
 
 linters-settings:
-  govet:
-    enable-all: true
   depguard:
     list-type: denylist
     include-go-root: true
     packages:
       - encoding/json
+      - github.com/pkg/errors
+  gci:
+    sections:
+      - standard
+      - default
+      - prefix(github.com/optimusmine/optimusmine)
+  gofumpt:
+    extra-rules: true
+  govet:
+    enable-all: true
+  nolintlint:
+    allow-leading-space: false
+    require-specific: true
 
 issues:
+  fix: true
   exclude-rules:
     - path: (.+)_test.go
       linters:
         - errcheck
         - funlen
-        - ifshort
         - gosec
-    - linters: [wsl]
-      text: return statements should not be cuddled if block has more than two lines
-    - linters: [wsl]
-      text: only cuddled expressions if assigning variable or using from line above
+    - path: (.+)_test.go
+      linters: [govet]
+      text: '^fieldalignment:'
+    - linters: [govet]
+      text: '^shadow: declaration of "err" shadows declaration'

README.md

@@ -219,7 +219,7 @@ You can create sub-routers using the `Group` function:
 ```go
 r := don.New(nil)
 sub := r.Group("/api")
-sub.Get("/hello")
+sub.Get("/hello", don.H(Hello))
 ```
 
 ## Middleware

api.go

@@ -27,13 +27,13 @@ type Router interface {
 }
 
 type API struct {
-	router *httprouter.Router
-	config *Config
-	mw     []Middleware
-
 	NotFound         fasthttp.RequestHandler
 	MethodNotAllowed fasthttp.RequestHandler
 	PanicHandler     func(*fasthttp.RequestCtx, interface{})
+
+	router *httprouter.Router
+	config *Config
+	mw     []Middleware
 }
 
 type Config struct {
@@ -89,7 +89,7 @@ func (r *API) Handle(method, path string, handle httprouter.Handle) {
 }
 
 func (r *API) Handler(method, path string, handle http.Handler) {
-	r.Handler(method, path, handle)
+	r.router.Handler(method, path, handle)
 }
 
 func (r *API) HandleFunc(method, path string, handle http.HandlerFunc) {

decoder/compile.go

@@ -14,12 +14,12 @@ var ErrUnsupportedType = errors.New("decoder: unsupported type")
 
 type decoder func(reflect.Value, Getter) error
 
+var unmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
+
 //nolint:cyclop
 func compile(typ reflect.Type, tagKey string, isPtr bool) (decoder, error) {
 	decoders := []decoder{}
 
-	unmarshalerType := reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()
-
 	for i := 0; i < typ.NumField(); i++ {
 		f := typ.Field(i)
 		if f.PkgPath != "" {

decoder/decode.go

@@ -14,7 +14,7 @@ func NewDecoder(tag string) *Decoder {
 	return &Decoder{tag: tag}
 }
 
-func (d *Decoder) Decode(data Getter, v any) (err error) {
+func (d *Decoder) Decode(data Getter, v any) error {
 	val := reflect.ValueOf(v).Elem()
 	if val.Kind() != reflect.Struct {
 		return ErrUnsupportedType
@@ -24,6 +24,7 @@ func (d *Decoder) Decode(data Getter, v any) (err error) {
 
 	dec, ok := d.cache.Load(t)
 	if !ok {
+		var err error
 		dec, err = compile(t, d.tag, t.Kind() == reflect.Ptr)
 		if err != nil {
 			return err

errors.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding"
 	"encoding/xml"
+	"errors"
 	"net/http"
 	"strconv"
 
@@ -32,8 +33,8 @@ func (e *HTTPError) Error() string {
 }
 
 func (e *HTTPError) StatusCode() int {
-	//nolint:errorlint
-	if sc, ok := e.err.(StatusCoder); ok {
+	var sc StatusCoder
+	if errors.As(e.err, &sc) {
 		return sc.StatusCode()
 	}
 
@@ -45,25 +46,44 @@ func (e *HTTPError) StatusCode() int {
 }
 
 func (e *HTTPError) MarshalText() ([]byte, error) {
+	var m encoding.TextMarshaler
+	if errors.As(e.err, &m) {
+		return m.MarshalText()
+	}
+
 	return []byte(e.Error()), nil
 }
 
 func (e *HTTPError) MarshalJSON() ([]byte, error) {
-	var buf bytes.Buffer
+	var m json.Marshaler
+	if errors.As(e.err, &m) {
+		return m.MarshalJSON()
+	}
 
+	var buf bytes.Buffer
 	buf.WriteString(`{"message":`)
 	buf.WriteString(strconv.Quote(e.Error()))
 	buf.WriteRune('}')
 
 	return buf.Bytes(), nil
 }
 
-func (e *HTTPError) MarshalXML(enc *xml.Encoder, _ xml.StartElement) error {
-	start := xml.StartElement{Name: xml.Name{Local: "message"}}
+func (e *HTTPError) MarshalXML(enc *xml.Encoder, start xml.StartElement) error {
+	var m xml.Marshaler
+	if errors.As(e.err, &m) {
+		return m.MarshalXML(enc, start)
+	}
+
+	start = xml.StartElement{Name: xml.Name{Local: "message"}}
 	return enc.EncodeElement(e.Error(), start)
 }
 
 func (e *HTTPError) MarshalYAML() (interface{}, error) {
+	var m yaml.Marshaler
+	if errors.As(e.err, &m) {
+		return m.MarshalYAML()
+	}
+
 	return map[string]string{"message": e.Error()}, nil
 }
 

handler.go

@@ -22,16 +22,15 @@ type Headerer interface {
 }
 
 // Handle is the type for your handlers.
-type Handle[T any, O any] func(ctx context.Context, request T) (O, error)
+type Handle[T, O any] func(ctx context.Context, request T) (O, error)
 
 // H wraps your handler function with the Go generics magic.
-//nolint:gocognit,cyclop
-func H[T any, O any](handle Handle[T, O]) httprouter.Handle {
+func H[T, O any](handle Handle[T, O]) httprouter.Handle { //nolint:gocognit,cyclop
 	var (
 		decodeHeader *decoder.HeaderDecoder
 		decodePath   *decoder.ParamsDecoder
 		decodeQuery  *decoder.ArgsDecoder
-		isNil        = makeNilCheck(*new(O))
+		isNil        = makeNilCheck(*new(O)) //nolint:gocritic
 	)
 
 	{

nilcheck.go

@@ -8,7 +8,7 @@ import (
 
 func makeNilCheck(zero any) func(v any) bool {
 	// Return true for nil interfaces.
-	if zero == *new(any) {
+	if zero == any(nil) {
 		return func(v any) bool { return v == nil }
 	}