Merge pull request #71 from unistack-org/lint

many lint fixes
2022-01-10 16:47:56 +03:00 · 2022-01-10 16:47:56 +03:00 · c26a7db47c
commit c26a7db47c
parent 8bd7323af1 74765b4c5f
23 changed files with 190 additions and 85 deletions
--- a/README.md
+++ b/README.md
@ -1,4 +1,4 @@
-# Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Doc](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/unistack-org/micro/v3?tab=overview) [![Status](https://github.com/unistack-org/micro/workflows/build/badge.svg?branch=master)](https://github.com/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Amaster+event%3Apush) [![Lint](https://goreportcard.com/badge/github.com/unistack-org/micro)](https://goreportcard.com/report/github.com/unistack-org/micro) [![Slack](https://img.shields.io/static/v1?label=micro&message=slack&color=blueviolet)](https://unistack-org.slack.com/messages/default)
+# Micro [![License](https://img.shields.io/:license-apache-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![Doc](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/github.com/unistack-org/micro/v3?tab=overview) [![Status](https://github.com/unistack-org/micro/workflows/build/badge.svg?branch=master)](https://github.com/unistack-org/micro/actions?query=workflow%3Abuild+branch%3Amaster+event%3Apush) [![Lint](https://goreportcard.com/report/go.unistack.org/micro/v3)](https://goreportcard.com/report/go.unistack.org/micro/v3) [![Slack](https://img.shields.io/static/v1?label=micro&message=slack&color=blueviolet)](https://unistack-org.slack.com/messages/default)

 Micro is a standard library for microservices.

--- a/client/client.go
+++ b/client/client.go
@ -92,10 +92,16 @@ type Stream interface {
 	Send(msg interface{}) error
 	// Recv will decode and read a response
 	Recv(msg interface{}) error
+	// SendMsg will encode and send a request
+	SendMsg(msg interface{}) error
+	// RecvMsg will decode and read a response
+	RecvMsg(msg interface{}) error
 	// Error returns the stream error
 	Error() error
 	// Close closes the stream
 	Close() error
+	// CloseSend closes the send direction of the stream
+	CloseSend() error
 }

 // Option used by the Client
--- a/client/noop.go
+++ b/client/noop.go
@ -119,6 +119,14 @@ func (n *noopStream) Recv(interface{}) error {
 	return nil
 }

+func (n *noopStream) SendMsg(interface{}) error {
+	return nil
+}
+
+func (n *noopStream) RecvMsg(interface{}) error {
+	return nil
+}
+
 func (n *noopStream) Error() error {
 	return nil
 }
@ -127,6 +135,10 @@ func (n *noopStream) Close() error {
 	return nil
 }

+func (n *noopStream) CloseSend() error {
+	return nil
+}
+
 func (n *noopMessage) Topic() string {
 	return n.topic
 }
--- a/flow/default.go
+++ b/flow/default.go
@ -349,6 +349,7 @@ func (w *microWorkflow) Execute(ctx context.Context, req *Message, opts ...Execu
 	return eid, err
 }

+// NewFlow create new flow
 func NewFlow(opts ...Option) Flow {
 	options := NewOptions(opts...)
 	return &microFlow{opts: options}
@ -574,11 +575,13 @@ func (s *microPublishStep) Execute(ctx context.Context, req *Message, opts ...Ex
 	return nil, nil
 }

+// NewCallStep create new step with client.Call
 func NewCallStep(service string, name string, method string, opts ...StepOption) Step {
 	options := NewStepOptions(opts...)
 	return &microCallStep{service: service, method: name + "." + method, opts: options}
 }

+// NewPublishStep create new step with client.Publish
 func NewPublishStep(topic string, opts ...StepOption) Step {
 	options := NewStepOptions(opts...)
 	return &microPublishStep{topic: topic, opts: options}
--- a/flow/options.go
+++ b/flow/options.go
@ -70,7 +70,7 @@ func Client(c client.Client) Option {

 // Context specifies a context for the service.
 // Can be used to signal shutdown of the flow
-// Can be used for extra option values.
+// or can be used for extra option values.
 func Context(ctx context.Context) Option {
 	return func(o *Options) {
 		o.Context = ctx
@ -91,7 +91,7 @@ func Store(s store.Store) Option {
 	}
 }

-// WorflowOption signature
+// WorflowOption func signature
 type WorkflowOption func(*WorkflowOptions)

 // WorkflowOptions holds workflow options
@ -107,6 +107,7 @@ func WorkflowID(id string) WorkflowOption {
 	}
 }

+// ExecuteOptions holds execute options
 type ExecuteOptions struct {
 	// Client holds the client.Client
 	Client client.Client
@ -128,56 +129,66 @@ type ExecuteOptions struct {
 	Async bool
 }

+// ExecuteOption func signature
 type ExecuteOption func(*ExecuteOptions)

+// ExecuteClient pass client.Client to ExecuteOption
 func ExecuteClient(c client.Client) ExecuteOption {
 	return func(o *ExecuteOptions) {
 		o.Client = c
 	}
 }

+// ExecuteTracer pass tracer.Tracer to ExecuteOption
 func ExecuteTracer(t tracer.Tracer) ExecuteOption {
 	return func(o *ExecuteOptions) {
 		o.Tracer = t
 	}
 }

+// ExecuteLogger pass logger.Logger to ExecuteOption
 func ExecuteLogger(l logger.Logger) ExecuteOption {
 	return func(o *ExecuteOptions) {
 		o.Logger = l
 	}
 }

+// ExecuteMeter pass meter.Meter to ExecuteOption
 func ExecuteMeter(m meter.Meter) ExecuteOption {
 	return func(o *ExecuteOptions) {
 		o.Meter = m
 	}
 }

+// ExecuteContext pass context.Context ot ExecuteOption
 func ExecuteContext(ctx context.Context) ExecuteOption {
 	return func(o *ExecuteOptions) {
 		o.Context = ctx
 	}
 }

+// ExecuteReverse says that dag must be run in reverse order
 func ExecuteReverse(b bool) ExecuteOption {
 	return func(o *ExecuteOptions) {
 		o.Reverse = b
 	}
 }

+// ExecuteTimeout pass timeout time.Duration for execution
 func ExecuteTimeout(td time.Duration) ExecuteOption {
 	return func(o *ExecuteOptions) {
 		o.Timeout = td
 	}
 }

+// ExecuteAsync says that caller does not wait for execution complete
 func ExecuteAsync(b bool) ExecuteOption {
 	return func(o *ExecuteOptions) {
 		o.Async = b
 	}
 }

+// NewExecuteOptions create new ExecuteOptions struct
 func NewExecuteOptions(opts ...ExecuteOption) ExecuteOptions {
 	options := ExecuteOptions{
 		Client:  client.DefaultClient,
@ -192,6 +203,7 @@ func NewExecuteOptions(opts ...ExecuteOption) ExecuteOptions {
 	return options
 }

+// StepOptions holds step options
 type StepOptions struct {
 	Context  context.Context
 	Fallback string
@ -199,8 +211,10 @@ type StepOptions struct {
 	Requires []string
 }

+// StepOption func signature
 type StepOption func(*StepOptions)

+// NewStepOptions create new StepOptions struct
 func NewStepOptions(opts ...StepOption) StepOptions {
 	options := StepOptions{
 		Context: context.Background(),
@ -211,18 +225,21 @@ func NewStepOptions(opts ...StepOption) StepOptions {
 	return options
 }

+// StepID sets the step id for dag
 func StepID(id string) StepOption {
 	return func(o *StepOptions) {
 		o.ID = id
 	}
 }

+// StepRequires specifies required steps
 func StepRequires(steps ...string) StepOption {
 	return func(o *StepOptions) {
 		o.Requires = steps
 	}
 }

+// StepFallback set the step to run on error
 func StepFallback(step string) StepOption {
 	return func(o *StepOptions) {
 		o.Fallback = step
--- a/function.go
+++ b/function.go
@ -1,3 +1,4 @@
+//go:build ignore
 // +build ignore

 package micro
--- a/function_test.go
+++ b/function_test.go
@ -1,3 +1,4 @@
+//go:build ignore
 // +build ignore

 package micro
--- a/logger/stdlogger.go
+++ b/logger/stdlogger.go
@ -10,6 +10,7 @@ type stdLogger struct {
 	level Level
 }

+// NewStdLogger returns new *log.Logger baked by logger.Logger implementation
 func NewStdLogger(l Logger, level Level) *log.Logger {
 	return log.New(&stdLogger{l: l, level: level}, "" /* prefix */, 0 /* flags */)
 }
@ -20,6 +21,7 @@ func (sl *stdLogger) Write(p []byte) (int, error) {
 	return len(p), nil
 }

+// RedirectStdLogger replace *log.Logger with logger.Logger implementation
 func RedirectStdLogger(l Logger, level Level) func() {
 	flags := log.Flags()
 	prefix := log.Prefix()
--- a/logger/wrapper.go
+++ b/logger/wrapper.go
@ -20,104 +20,104 @@ type Wrapper interface {
 	Logf(LogfFunc) LogfFunc
 }

-var _ Logger = &OmitLogger{}
+var _ Logger = &omitLogger{}

-type OmitLogger struct {
+type omitLogger struct {
 	l Logger
 }

 func NewOmitLogger(l Logger) Logger {
-	return &OmitLogger{l: l}
+	return &omitLogger{l: l}
 }

-func (w *OmitLogger) Init(opts ...Option) error {
+func (w *omitLogger) Init(opts ...Option) error {
 	return w.l.Init(append(opts, WrapLogger(NewOmitWrapper()))...)
 }

-func (w *OmitLogger) V(level Level) bool {
+func (w *omitLogger) V(level Level) bool {
 	return w.l.V(level)
 }

-func (w *OmitLogger) Level(level Level) {
+func (w *omitLogger) Level(level Level) {
 	w.l.Level(level)
 }

-func (w *OmitLogger) Clone(opts ...Option) Logger {
+func (w *omitLogger) Clone(opts ...Option) Logger {
 	return w.l.Clone(opts...)
 }

-func (w *OmitLogger) Options() Options {
+func (w *omitLogger) Options() Options {
 	return w.l.Options()
 }

-func (w *OmitLogger) Fields(fields ...interface{}) Logger {
+func (w *omitLogger) Fields(fields ...interface{}) Logger {
 	return w.l.Fields(fields...)
 }

-func (w *OmitLogger) Info(ctx context.Context, args ...interface{}) {
+func (w *omitLogger) Info(ctx context.Context, args ...interface{}) {
 	w.l.Info(ctx, args...)
 }

-func (w *OmitLogger) Trace(ctx context.Context, args ...interface{}) {
+func (w *omitLogger) Trace(ctx context.Context, args ...interface{}) {
 	w.l.Trace(ctx, args...)
 }

-func (w *OmitLogger) Debug(ctx context.Context, args ...interface{}) {
+func (w *omitLogger) Debug(ctx context.Context, args ...interface{}) {
 	w.l.Debug(ctx, args...)
 }

-func (w *OmitLogger) Warn(ctx context.Context, args ...interface{}) {
+func (w *omitLogger) Warn(ctx context.Context, args ...interface{}) {
 	w.l.Warn(ctx, args...)
 }

-func (w *OmitLogger) Error(ctx context.Context, args ...interface{}) {
+func (w *omitLogger) Error(ctx context.Context, args ...interface{}) {
 	w.l.Error(ctx, args...)
 }

-func (w *OmitLogger) Fatal(ctx context.Context, args ...interface{}) {
+func (w *omitLogger) Fatal(ctx context.Context, args ...interface{}) {
 	w.l.Fatal(ctx, args...)
 }

-func (w *OmitLogger) Infof(ctx context.Context, msg string, args ...interface{}) {
+func (w *omitLogger) Infof(ctx context.Context, msg string, args ...interface{}) {
 	w.l.Infof(ctx, msg, args...)
 }

-func (w *OmitLogger) Tracef(ctx context.Context, msg string, args ...interface{}) {
+func (w *omitLogger) Tracef(ctx context.Context, msg string, args ...interface{}) {
 	w.l.Tracef(ctx, msg, args...)
 }

-func (w *OmitLogger) Debugf(ctx context.Context, msg string, args ...interface{}) {
+func (w *omitLogger) Debugf(ctx context.Context, msg string, args ...interface{}) {
 	w.l.Debugf(ctx, msg, args...)
 }

-func (w *OmitLogger) Warnf(ctx context.Context, msg string, args ...interface{}) {
+func (w *omitLogger) Warnf(ctx context.Context, msg string, args ...interface{}) {
 	w.l.Warnf(ctx, msg, args...)
 }

-func (w *OmitLogger) Errorf(ctx context.Context, msg string, args ...interface{}) {
+func (w *omitLogger) Errorf(ctx context.Context, msg string, args ...interface{}) {
 	w.l.Errorf(ctx, msg, args...)
 }

-func (w *OmitLogger) Fatalf(ctx context.Context, msg string, args ...interface{}) {
+func (w *omitLogger) Fatalf(ctx context.Context, msg string, args ...interface{}) {
 	w.l.Fatalf(ctx, msg, args...)
 }

-func (w *OmitLogger) Log(ctx context.Context, level Level, args ...interface{}) {
+func (w *omitLogger) Log(ctx context.Context, level Level, args ...interface{}) {
 	w.l.Log(ctx, level, args...)
 }

-func (w *OmitLogger) Logf(ctx context.Context, level Level, msg string, args ...interface{}) {
+func (w *omitLogger) Logf(ctx context.Context, level Level, msg string, args ...interface{}) {
 	w.l.Logf(ctx, level, msg, args...)
 }

-func (w *OmitLogger) String() string {
+func (w *omitLogger) String() string {
 	return w.l.String()
 }

-type OmitWrapper struct{}
+type omitWrapper struct{}

 func NewOmitWrapper() Wrapper {
-	return &OmitWrapper{}
+	return &omitWrapper{}
 }

 func getArgs(args []interface{}) []interface{} {
@ -153,13 +153,13 @@ func getArgs(args []interface{}) []interface{} {
 	return nargs
 }

-func (w *OmitWrapper) Log(fn LogFunc) LogFunc {
+func (w *omitWrapper) Log(fn LogFunc) LogFunc {
 	return func(ctx context.Context, level Level, args ...interface{}) {
 		fn(ctx, level, getArgs(args)...)
 	}
 }

-func (w *OmitWrapper) Logf(fn LogfFunc) LogfFunc {
+func (w *omitWrapper) Logf(fn LogfFunc) LogfFunc {
 	return func(ctx context.Context, level Level, msg string, args ...interface{}) {
 		fn(ctx, level, msg, getArgs(args)...)
 	}
--- a/meter/handler/handler_micro.pb.go
+++ b/meter/handler/handler_micro.pb.go
@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-micro. DO NOT EDIT.
-// protoc-gen-go-micro version: v3.5.2
+// protoc-gen-go-micro version: v3.5.3
 // source: handler.proto

 package handler
--- a/meter/handler/handler_micro_http.pb.go
+++ b/meter/handler/handler_micro_http.pb.go
@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-micro. DO NOT EDIT.
-// protoc-gen-go-micro version: v3.5.2
+// protoc-gen-go-micro version: v3.5.3
 // source: handler.proto

 package handler
--- a/meter/options.go
+++ b/meter/options.go
@ -9,7 +9,7 @@ import (
 // Option powers the configuration for metrics implementations:
 type Option func(*Options)

-// Options for metrics implementations:
+// Options for metrics implementations
 type Options struct {
 	// Logger used for logging
 	Logger logger.Logger
@ -102,6 +102,7 @@ func Logger(l logger.Logger) Option {
 	}
 }

+// Labels sets the meter labels
 func Labels(ls ...string) Option {
 	return func(o *Options) {
 		o.Labels = append(o.Labels, ls...)
--- a/meter/wrapper/wrapper.go
+++ b/meter/wrapper/wrapper.go
@ -11,24 +11,37 @@ import (
 )

 var (
+	// ClientRequestDurationSeconds specifies meter metric name
 	ClientRequestDurationSeconds = "client_request_duration_seconds"
+	// ClientRequestLatencyMicroseconds specifies meter metric name
 	ClientRequestLatencyMicroseconds = "client_request_latency_microseconds"
+	// ClientRequestTotal specifies meter metric name
 	ClientRequestTotal = "client_request_total"
+	// ClientRequestInflight specifies meter metric name
 	ClientRequestInflight = "client_request_inflight"
-
+	// ServerRequestDurationSeconds specifies meter metric name
 	ServerRequestDurationSeconds = "server_request_duration_seconds"
+	// ServerRequestLatencyMicroseconds specifies meter metric name
 	ServerRequestLatencyMicroseconds = "server_request_latency_microseconds"
+	// ServerRequestTotal specifies meter metric name
 	ServerRequestTotal = "server_request_total"
+	// ServerRequestInflight specifies meter metric name
 	ServerRequestInflight = "server_request_inflight"
-
+	// PublishMessageDurationSeconds specifies meter metric name
 	PublishMessageDurationSeconds = "publish_message_duration_seconds"
+	// PublishMessageLatencyMicroseconds specifies meter metric name
 	PublishMessageLatencyMicroseconds = "publish_message_latency_microseconds"
+	// PublishMessageTotal specifies meter metric name
 	PublishMessageTotal = "publish_message_total"
+	// PublishMessageInflight specifies meter metric name
 	PublishMessageInflight = "publish_message_inflight"
-
+	// SubscribeMessageDurationSeconds specifies meter metric name
 	SubscribeMessageDurationSeconds = "subscribe_message_duration_seconds"
+	// SubscribeMessageLatencyMicroseconds specifies meter metric name
 	SubscribeMessageLatencyMicroseconds = "subscribe_message_latency_microseconds"
+	// SubscribeMessageTotal specifies meter metric name
 	SubscribeMessageTotal = "subscribe_message_total"
+	// SubscribeMessageInflight specifies meter metric name
 	SubscribeMessageInflight = "subscribe_message_inflight"

 	labelSuccess  = "success"
@ -40,14 +53,17 @@ var (
 	DefaultSkipEndpoints = []string{"Meter.Metrics"}
 )

+// Options struct
 type Options struct {
 	Meter         meter.Meter
 	lopts         []meter.Option
 	SkipEndpoints []string
 }

+// Option func signature
 type Option func(*Options)

+// NewOptions creates new Options struct
 func NewOptions(opts ...Option) Options {
 	options := Options{
 		Meter:         meter.DefaultMeter,
@ -60,30 +76,35 @@ func NewOptions(opts ...Option) Options {
 	return options
 }

+// ServiceName passes service name to meter label
 func ServiceName(name string) Option {
 	return func(o *Options) {
 		o.lopts = append(o.lopts, meter.Labels("name", name))
 	}
 }

+// ServiceVersion passes service version to meter label
 func ServiceVersion(version string) Option {
 	return func(o *Options) {
 		o.lopts = append(o.lopts, meter.Labels("version", version))
 	}
 }

+// ServiceID passes service id to meter label
 func ServiceID(id string) Option {
 	return func(o *Options) {
 		o.lopts = append(o.lopts, meter.Labels("id", id))
 	}
 }

+// Meter passes meter
 func Meter(m meter.Meter) Option {
 	return func(o *Options) {
 		o.Meter = m
 	}
 }

+// SkipEndpoint add endpoint to skip
 func SkipEndoints(eps ...string) Option {
 	return func(o *Options) {
 		o.SkipEndpoints = append(o.SkipEndpoints, eps...)
@ -96,6 +117,7 @@ type wrapper struct {
 	opts     Options
 }

+// NewClientWrapper create new client wrapper
 func NewClientWrapper(opts ...Option) client.Wrapper {
 	return func(c client.Client) client.Client {
 		handler := &wrapper{
@ -106,6 +128,7 @@ func NewClientWrapper(opts ...Option) client.Wrapper {
 	}
 }

+// NewCallWrapper create new call wrapper
 func NewCallWrapper(opts ...Option) client.CallWrapper {
 	return func(fn client.CallFunc) client.CallFunc {
 		handler := &wrapper{
@ -231,6 +254,7 @@ func (w *wrapper) Publish(ctx context.Context, p client.Message, opts ...client.
 	return err
 }

+// NewHandlerWrapper create new server handler wrapper
 func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {
 	handler := &wrapper{
 		opts: NewOptions(opts...),
@ -240,7 +264,7 @@ func NewHandlerWrapper(opts ...Option) server.HandlerWrapper {

 func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
 	return func(ctx context.Context, req server.Request, rsp interface{}) error {
-		endpoint := req.Endpoint()
+		endpoint := req.Service() + "." + req.Endpoint()
 		for _, ep := range w.opts.SkipEndpoints {
 			if ep == endpoint {
 				return fn(ctx, req, rsp)
@ -270,6 +294,7 @@ func (w *wrapper) HandlerFunc(fn server.HandlerFunc) server.HandlerFunc {
 	}
 }

+// NewSubscribeWrapper create server subscribe wrapper
 func NewSubscriberWrapper(opts ...Option) server.SubscriberWrapper {
 	handler := &wrapper{
 		opts: NewOptions(opts...),
--- a/server/health/health_micro.pb.go
+++ b/server/health/health_micro.pb.go
@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-micro. DO NOT EDIT.
-// protoc-gen-go-micro version: v3.5.2
+// protoc-gen-go-micro version: v3.5.3
 // source: health.proto

 package health
--- a/server/health/health_micro_http.pb.go
+++ b/server/health/health_micro_http.pb.go
@ -1,5 +1,5 @@
 // Code generated by protoc-gen-go-micro. DO NOT EDIT.
-// protoc-gen-go-micro version: v3.5.2
+// protoc-gen-go-micro version: v3.5.3
 // source: health.proto

 package health
--- a/server/server.go
+++ b/server/server.go
@ -123,11 +123,21 @@ type Response interface {
 // The last error will be left in Error().
 // EOF indicates end of the stream.
 type Stream interface {
+	// Context for the stream
 	Context() context.Context
+	// Request returns request
 	Request() Request
+	// Send will encode and send a request
 	Send(msg interface{}) error
+	// Recv will decode and read a response
 	Recv(msg interface{}) error
+	// SendMsg will encode and send a request
+	SendMsg(msg interface{}) error
+	// RecvMsg will decode and read a response
+	RecvMsg(msg interface{}) error
+	// Error returns stream error
 	Error() error
+	// Close closes the stream
 	Close() error
 }

--- a/util/buf/buf.go
+++ b/util/buf/buf.go
@ -2,8 +2,12 @@ package buf // import "go.unistack.org/micro/v3/util/buf"

 import (
 	"bytes"
+	"io"
 )

+var _ io.Closer = &Buffer{}
+
+// Buffer bytes.Buffer wrapper to satisfie io.Closer interface
 type Buffer struct {
 	*bytes.Buffer
 }
--- a/util/http/http_test.go
+++ b/util/http/http_test.go
@ -1,3 +1,4 @@
+//go:build ignore
 // +build ignore

 package http
--- a/util/http/trie.go
+++ b/util/http/trie.go
@ -45,8 +45,7 @@ var methodMap = map[string]methodTyp{
 	http.MethodTrace:   mTRACE,
 }

-// RegisterMethod adds support for custom HTTP method handlers, available
-// via Router#Method and Router#MethodFunc
+// RegisterMethod adds support for custom HTTP method handlers
 func RegisterMethod(method string) error {
 	if method == "" {
 		return nil
@ -75,13 +74,13 @@ const (
 	ntCatchAll                // /api/v1/*
 )

-func NewTrie() *Node {
-	return &Node{}
+// NewTrie create new tree
+func NewTrie() *Trie {
+	return &Trie{}
 }

-type Trie = Node
-
-type Node struct {
+// Trie holds nodes for path based tree search
+type Trie struct {
 	// regexp matcher for regexp nodes
 	rex *regexp.Regexp

@ -128,7 +127,8 @@ func (s endpoints) Value(method methodTyp) *endpoint {
 	return mh
 }

-func (n *Node) Insert(methods []string, pattern string, handler interface{}) error {
+// Insert add elemenent to tree
+func (n *Trie) Insert(methods []string, pattern string, handler interface{}) error {
 	var err error
 	for _, method := range methods {
 		if err = n.insert(methodMap[method], pattern, handler); err != nil {
@ -138,8 +138,8 @@ func (n *Node) Insert(methods []string, pattern string, handler interface{}) err
 	return nil
 }

-func (n *Node) insert(method methodTyp, pattern string, handler interface{}) error {
-	var parent *Node
+func (n *Trie) insert(method methodTyp, pattern string, handler interface{}) error {
+	var parent *Trie
 	search := pattern

 	for {
@ -175,8 +175,8 @@ func (n *Node) insert(method methodTyp, pattern string, handler interface{}) err

 		// No edge, create one
 		if n == nil {
-			child := &Node{typ: ntStatic, label: label, tail: segTail, prefix: search}
-			var hn *Node
+			child := &Trie{typ: ntStatic, label: label, tail: segTail, prefix: search}
+			var hn *Trie
 			hn, err = parent.addChild(child, search)
 			if err != nil {
 				return err
@ -205,7 +205,7 @@ func (n *Node) insert(method methodTyp, pattern string, handler interface{}) err
 		}

 		// Split the node
-		child := &Node{
+		child := &Trie{
 			typ:    ntStatic,
 			prefix: search[:commonPrefix],
 		}
@ -227,12 +227,12 @@ func (n *Node) insert(method methodTyp, pattern string, handler interface{}) err
 		}

 		// Create a new edge for the node
-		subchild := &Node{
+		subchild := &Trie{
 			typ:    ntStatic,
 			label:  search[0],
 			prefix: search,
 		}
-		var hn *Node
+		var hn *Trie
 		hn, err = child.addChild(subchild, search)
 		if err != nil {
 			return err
@ -245,7 +245,7 @@ func (n *Node) insert(method methodTyp, pattern string, handler interface{}) err
 // For a URL router like chi's, we split the static, param, regexp and wildcard segments
 // into different nodes. In addition, addChild will recursively call itself until every
 // pattern segment is added to the url pattern tree as individual nodes, depending on type.
-func (n *Node) addChild(child *Node, prefix string) (*Node, error) {
+func (n *Trie) addChild(child *Trie, prefix string) (*Trie, error) {
 	search := prefix

 	// handler leaf node added to the tree is the child.
@ -298,7 +298,7 @@ func (n *Node) addChild(child *Node, prefix string) (*Node, error) {

 				search = search[segStartIdx:] // advance search position

-				nn := &Node{
+				nn := &Trie{
 					typ:    ntStatic,
 					label:  search[0],
 					prefix: search,
@ -321,7 +321,7 @@ func (n *Node) addChild(child *Node, prefix string) (*Node, error) {
 			// add the param edge node
 			search = search[segStartIdx:]

-			nn := &Node{
+			nn := &Trie{
 				typ:   segTyp,
 				label: search[0],
 				tail:  segTail,
@ -339,7 +339,7 @@ func (n *Node) addChild(child *Node, prefix string) (*Node, error) {
 	return hn, nil
 }

-func (n *Node) replaceChild(label, tail byte, child *Node) error {
+func (n *Trie) replaceChild(label, tail byte, child *Trie) error {
 	for i := 0; i < len(n.children[child.typ]); i++ {
 		if n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail {
 			n.children[child.typ][i] = child
@ -351,7 +351,7 @@ func (n *Node) replaceChild(label, tail byte, child *Node) error {
 	return fmt.Errorf("replacing missing child")
 }

-func (n *Node) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *Node {
+func (n *Trie) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *Trie {
 	nds := n.children[ntyp]
 	for i := 0; i < len(nds); i++ {
 		if nds[i].label == label && nds[i].tail == tail {
@ -364,7 +364,7 @@ func (n *Node) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *Node {
 	return nil
 }

-func (n *Node) setEndpoint(method methodTyp, handler interface{}, pattern string) error {
+func (n *Trie) setEndpoint(method methodTyp, handler interface{}, pattern string) error {
 	// Set the handler for the method type on the node
 	if n.endpoints == nil {
 		n.endpoints = make(endpoints)
@ -398,7 +398,8 @@ func (n *Node) setEndpoint(method methodTyp, handler interface{}, pattern string
 	return nil
 }

-func (n *Node) Search(method string, path string) (interface{}, map[string]string, bool) {
+// Search try to find element in tree with path and method
+func (n *Trie) Search(method string, path string) (interface{}, map[string]string, bool) {
 	params := &routeParams{}
 	// Find the routing handlers for the path
 	rn := n.findRoute(params, methodMap[method], path)
@ -425,7 +426,7 @@ type routeParams struct {

 // Recursive edge traversal by checking all nodeTyp groups along the way.
 // It's like searching through a multi-dimensional radix trie.
-func (n *Node) findRoute(params *routeParams, method methodTyp, path string) *Node {
+func (n *Trie) findRoute(params *routeParams, method methodTyp, path string) *Trie {
 	nn := n
 	search := path

@ -435,7 +436,7 @@ func (n *Node) findRoute(params *routeParams, method methodTyp, path string) *No
 			continue
 		}

-		var xn *Node
+		var xn *Trie
 		xsearch := search

 		var label byte
@ -550,7 +551,7 @@ func (n *Node) findRoute(params *routeParams, method methodTyp, path string) *No
 	return nil
 }

-func (n *Node) isLeaf() bool {
+func (n *Trie) isLeaf() bool {
 	return n.endpoints != nil
 }

@ -665,7 +666,7 @@ func longestPrefix(k1, k2 string) int {
 	return i
 }

-type nodes []*Node
+type nodes []*Trie

 // Sort the list of nodes by label
 func (ns nodes) Sort()              { sort.Sort(ns); ns.tailSort() }
@ -684,7 +685,7 @@ func (ns nodes) tailSort() {
 	}
 }

-func (ns nodes) findEdge(label byte) *Node {
+func (ns nodes) findEdge(label byte) *Trie {
 	num := len(ns)
 	idx := 0
 	i, j := 0, num-1
--- a/util/pool/default_test.go
+++ b/util/pool/default_test.go
@ -1,3 +1,4 @@
+//go:build ignore
 // +build ignore

 package pool
--- a/util/rand/rand.go
+++ b/util/rand/rand.go
@ -10,16 +10,19 @@ type Rand struct {
 	buf [8]byte
 }

+// Int31 function implementation
 func (r *Rand) Int31() int32 {
 	_, _ = crand.Read(r.buf[:4])
 	return int32(binary.BigEndian.Uint32(r.buf[:4]) & ^uint32(1<<31))
 }

+// Int function implementation
 func (r *Rand) Int() int {
 	u := uint(r.Int63())
 	return int(u << 1 >> 1) // clear sign bit if int == int32
 }

+// Float64 function implementation
 func (r *Rand) Float64() float64 {
 again:
 	f := float64(r.Int63()) / (1 << 63)
@ -29,6 +32,7 @@ again:
 	return f
 }

+// Float32 function implementation
 func (r *Rand) Float32() float32 {
 again:
 	f := float32(r.Float64())
@ -38,14 +42,17 @@ again:
 	return f
 }

+// Uint32 function implementation
 func (r *Rand) Uint32() uint32 {
 	return uint32(r.Int63() >> 31)
 }

+// Uint64 function implementation
 func (r *Rand) Uint64() uint64 {
 	return uint64(r.Int63())>>31 | uint64(r.Int63())<<32
 }

+// Intn function implementation
 func (r *Rand) Intn(n int) int {
 	if n <= 1<<31-1 {
 		return int(r.Int31n(int32(n)))
@ -53,12 +60,13 @@ func (r *Rand) Intn(n int) int {
 	return int(r.Int63n(int64(n)))
 }

+// Int63 function implementation
 func (r *Rand) Int63() int64 {
 	_, _ = crand.Read(r.buf[:])
 	return int64(binary.BigEndian.Uint64(r.buf[:]) & ^uint64(1<<63))
 }

-// Int31n copied from the standard library math/rand implementation of Int31n
+// Int31n function implementation copied from the standard library math/rand implementation of Int31n
 func (r *Rand) Int31n(n int32) int32 {
 	if n&(n-1) == 0 { // n is power of two, can mask
 		return r.Int31() & (n - 1)
@ -71,7 +79,7 @@ func (r *Rand) Int31n(n int32) int32 {
 	return v % n
 }

-// Int63n copied from the standard library math/rand implementation of Int63n
+// Int63n function implementation copied from the standard library math/rand implementation of Int63n
 func (r *Rand) Int63n(n int64) int64 {
 	if n&(n-1) == 0 { // n is power of two, can mask
 		return r.Int63() & (n - 1)
@ -84,7 +92,7 @@ func (r *Rand) Int63n(n int64) int64 {
 	return v % n
 }

-// Shuffle copied from the standard library math/rand implementation of Shuffle
+// Shuffle function implementation copied from the standard library math/rand implementation of Shuffle
 func (r *Rand) Shuffle(n int, swap func(i, j int)) {
 	if n < 0 {
 		panic("invalid argument to Shuffle")
--- a/util/reflect/reflect.go
+++ b/util/reflect/reflect.go
@ -10,30 +10,40 @@ import (
 )

 var (
+	// ErrInvalidStruct happens when passed not struct and not struct pointer
 	ErrInvalidStruct = errors.New("invalid struct specified")
+	// ErrInvalidValue happens when passed invalid value for field
 	ErrInvalidValue = errors.New("invalid value specified")
+	// ErrNotFound happens when struct field not found
 	ErrNotFound = errors.New("struct field not found")
 )

+// Option func signature
 type Option func(*Options)

+// Options for merge
 type Options struct {
+	// Tags specifies tags to lookup
 	Tags []string
+	// SliceAppend controls slice appending
 	SliceAppend bool
 }

+// Tags sets the merge tags for lookup
 func Tags(t []string) Option {
 	return func(o *Options) {
 		o.Tags = t
 	}
 }

+// SliceAppend sets the option
 func SliceAppend(b bool) Option {
 	return func(o *Options) {
 		o.SliceAppend = b
 	}
 }

+// Merge merges map[string]interface{} to destination struct
 func Merge(dst interface{}, mp map[string]interface{}, opts ...Option) error {
 	var err error
 	var sval reflect.Value
@ -481,6 +491,7 @@ func IsEmpty(v reflect.Value) bool {
 	return true
 }

+// FieldName returns map field name that can be looked up in struct field
 func FieldName(name string) string {
 	newstr := make([]rune, 0, len(name))
 	for idx, chr := range name {
--- a/util/token/basic/basic_test.go
+++ b/util/token/basic/basic_test.go
@ -1,3 +1,4 @@
+//go:build ignore
 // +build ignore

 package basic