massive refactoring

Author: bhmj

.golangci.yml

@@ -0,0 +1,72 @@
+version: "2"
+run:
+  tests: false
+linters:
+  default: all
+  disable:
+    - embeddedstructfieldcheck   # too opinionated
+    - err113                     # will fix later
+    - exhaustruct                # I don't declare default fields!
+    - exhaustive                 # missing cases in switch are deliberate
+    - funcorder                  # my code, my order
+    - godox                      # I need TODOs
+    - godot                      # too opinionated
+    - ireturn                    # I don't care for returning interfaces. It's easier this way
+    - noinlineerr                # my code, my inlining
+    - nlreturn                   # too opinionated
+    - tagalign                   # too opinionated
+    - varnamelen                 # I decide if the variable name is long enough
+    - wrapcheck                  # will fix later
+    - wsl                        # deprecated
+    - wsl_v5                     # too opinionated
+  settings:
+    funlen:
+      lines: 80
+      statements: 60
+    depguard:
+      rules:
+        main:
+          deny:
+            - pkg: "math/rand$"
+              desc: use math/rand/v2
+            - pkg: "github.com/sirupsen/logrus"
+              desc: not allowed
+            - pkg: "github.com/pkg/errors"
+              desc: Should be replaced by standard lib errors package
+    lll:
+      line-length: 180
+    cyclop:
+      max-complexity: 15
+    tagliatelle:
+      # check the struck tag name case
+      case:
+        # use the struct field name to check the name of the struct tag
+        rules:
+          # any struct tag type can be used.
+          # support string case: `camel`, `pascal`, `kebab`, `snake`, `goCamel`, `goPascal`, `goKebab`, `goSnake`, `upper`, `lower`
+          json: snake
+          yaml: snake
+        use-field-name: true
+  exclusions:
+    generated: lax
+    presets:
+      - comments
+      - common-false-positives
+      - legacy
+      - std-error-handling
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
+formatters:
+  enable:
+    - gci
+    - gofmt
+    - gofumpt
+    - goimports
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$

Makefile

@@ -1,7 +1,40 @@
+define USAGE
+
+"Go blocks" project. A collection of simple but useful Go packages.
+
+Usage: make <target>
+
+some of the <targets> are:
+
+  lint             - run linters
+  test             - run tests
+  update-deps      - update dependencies
+
+endef
+export USAGE
+
+define CAKE
+   \033[1;31m. . .\033[0m
+   i i i
+  %~%~%~%
+  |||||||
+-=========-
+endef
+export CAKE
+
+help:
+	@echo "$$USAGE"
+
 test:
 	go test -cover ./...
 
 lint:
 	golangci-lint run
 
-.PHONY: test
+update-deps:
+	go get -u ./... && go mod tidy && go mod vendor
+
+cake:
+	@printf "%b\n" "$$CAKE"
+
+.PHONY: help test lint update-deps cake

apiauth/interface.go

@@ -2,7 +2,7 @@ package apiauth
 
 import "net/http"
 
-// Authentication provider.
+// Auth is authentication provider
 type Auth interface {
 	Authorized(req *http.Request) error
 }

conftool/conftool.go

@@ -77,7 +77,7 @@ func parseRead(f io.Reader, decoder unmarshaller, cfg any) error {
 func defaultsAndRequired(cfg any) error {
 	reqs := defsAndReqs(cfg)
 	if len(reqs) > 0 {
-		return fmt.Errorf("required config parameters not set: %s", strings.Join(reqs, ", "))
+		return fmt.Errorf("required config parameters not set: %s", strings.Join(reqs, ", ")) //nolint:err113
 	}
 	return nil
 }
@@ -87,12 +87,12 @@ func defsAndReqs(cfg any) []string {
 	val := reflect.ValueOf(cfg).Elem()
 	typ := val.Type()
 
-	for i := 0; i < val.NumField(); i++ {
+	for i := range val.NumField() {
 		field := val.Field(i)
 		fieldType := typ.Field(i)
 
 		// Set the default value based on the field kind
-		if field.Kind() == reflect.Struct {
+		if field.Kind() == reflect.Struct { //nolint:nestif
 			// If it's a struct, recurse
 			reqs = append(reqs, defsAndReqs(field.Addr().Interface())...)
 		} else if field.CanSet() {
@@ -101,11 +101,7 @@ func defsAndReqs(cfg any) []string {
 				continue
 			}
 			// Check if the field has a `required` tag
-			isRequired := false
-			required, ok := fieldType.Tag.Lookup("required")
-			if ok && required == "true" {
-				isRequired = true
-			}
+			isRequired := isFieldRequired(fieldType)
 			// Check if the field has a `default` tag
 			defaultValue, hasDefault := fieldType.Tag.Lookup("default")
 			if !hasDefault {
@@ -115,41 +111,20 @@ func defsAndReqs(cfg any) []string {
 				continue
 			}
 
-			switch field.Kind() {
-			case reflect.String:
-				field.SetString(defaultValue)
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				intValue, err := strconv.ParseInt(defaultValue, 10, 64)
-				if err != nil {
-					errSyntax := strconv.ErrSyntax
-					if errors.Is(err, errSyntax) {
-						dur, err := time.ParseDuration(defaultValue)
-						if err == nil {
-							field.SetInt(int64(dur))
-						}
-					}
-				} else {
-					field.SetInt(intValue)
-				}
-
-			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-				if uintValue, err := strconv.ParseUint(defaultValue, 10, 64); err == nil {
-					field.SetUint(uintValue)
-				}
-			case reflect.Float32, reflect.Float64:
-				if floatValue, err := strconv.ParseFloat(defaultValue, 64); err == nil {
-					field.SetFloat(floatValue)
-				}
-			case reflect.Bool:
-				if boolValue, err := strconv.ParseBool(defaultValue); err == nil {
-					field.SetBool(boolValue)
-				}
-			}
+			setField(field, defaultValue)
 		}
 	}
 	return reqs
 }
 
+func isFieldRequired(field reflect.StructField) bool {
+	required, ok := field.Tag.Lookup("required")
+	if ok && required == "true" {
+		return true
+	}
+	return false
+}
+
 func isFieldEmpty(v reflect.Value) bool {
 	switch v.Kind() {
 	case reflect.Slice:
@@ -163,3 +138,36 @@ func isFieldEmpty(v reflect.Value) bool {
 		return v.Interface() == reflect.Zero(v.Type()).Interface()
 	}
 }
+
+func setField(field reflect.Value, defaultValue string) {
+	switch field.Kind() {
+	case reflect.String:
+		field.SetString(defaultValue)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		intValue, err := strconv.ParseInt(defaultValue, 10, 64)
+		if err != nil {
+			errSyntax := strconv.ErrSyntax
+			if errors.Is(err, errSyntax) {
+				dur, err := time.ParseDuration(defaultValue)
+				if err == nil {
+					field.SetInt(int64(dur))
+				}
+			}
+		} else {
+			field.SetInt(intValue)
+		}
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		if uintValue, err := strconv.ParseUint(defaultValue, 10, 64); err == nil {
+			field.SetUint(uintValue)
+		}
+	case reflect.Float32, reflect.Float64:
+		if floatValue, err := strconv.ParseFloat(defaultValue, 64); err == nil {
+			field.SetFloat(floatValue)
+		}
+	case reflect.Bool:
+		if boolValue, err := strconv.ParseBool(defaultValue); err == nil {
+			field.SetBool(boolValue)
+		}
+	}
+}

conncount/transport.go

@@ -24,8 +24,8 @@ type Transport struct {
 type dialer func(ctx context.Context, network string, addr string) (net.Conn, error)
 
 // NewTransport creates Transport with a connection counter.
-// prev is a Transport to be wrapped
-// callback is a function to be called when connection counter changes
+// prev is a Transport to be wrapped.
+// callback is a function to be called when connection counter changes.
 func NewTransport(logger log.MetaLogger, prev *http.Transport, callback func(int64)) *Transport {
 	var counter int64
 	tran := &Transport{Transport: prev, connCounter: &counter}
@@ -54,8 +54,8 @@ func NewTransport(logger log.MetaLogger, prev *http.Transport, callback func(int
 			return instrumentedConn, nil
 		}
 	}
-	tran.Transport.DialContext = dialWithCounter(prevDialer)
-	tran.Transport.DialTLSContext = dialWithCounter(prevTLSDialer)
+	tran.DialContext = dialWithCounter(prevDialer)
+	tran.DialTLSContext = dialWithCounter(prevTLSDialer)
 	return tran
 }
 
@@ -64,7 +64,7 @@ func (tran *Transport) getPreviousDialer() func(ctx context.Context, network, ad
 		return tran.DialContext
 	}
 	if tran.Dial != nil {
-		return func(ctx context.Context, network, addr string) (net.Conn, error) {
+		return func(_ context.Context, network, addr string) (net.Conn, error) {
 			return tran.Dial(network, addr) //nolint:wrapcheck
 		}
 	}
@@ -77,7 +77,7 @@ func (tran *Transport) getPreviousTLSDialer() func(ctx context.Context, network,
 		return tran.DialTLSContext
 	}
 	if tran.DialTLS != nil {
-		return func(ctx context.Context, network, addr string) (net.Conn, error) {
+		return func(_ context.Context, network, addr string) (net.Conn, error) {
 			return tran.DialTLS(network, addr) //nolint:wrapcheck
 		}
 	}