errors.*DataError.Is - Code Metrics - gravitton/errors - Measure and Improve Code Quality continuously with Scrutinizer

errors.*DataError.Is A
last analyzed 2025-08-06 19:54 UTC

↳ Parent: error.go

Complexity

Conditions

Size

Total Lines	17
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	5

Importance

Changes

Metric	Value
cc	5
eloc	10
dl	0
loc	17
ccs	9
cts	9
cp	1
crap	5
rs	9.3333
c	0
b	0
f	0
nop	1

package errors

import (
	"errors"
	"fmt"
	"reflect"
)

type DataError struct {
	err   error
	data  map[string]any
	cause error
}

func New(text string) *DataError {
	return &DataError{
		err: errors.New(text),
	}
}

func Newf(format string, v ...any) *DataError {
	return &DataError{
		err: fmt.Errorf(format, v...),
	}
}

func Wrap(err any) *DataError {
	if err == nil {
		return nil
	}

	var e error
	switch t := err.(type) {
	case *DataError:
		return t
	case error:
		e = t
	default:
		e = fmt.Errorf("%v", err)
	}

	return &DataError{
		err: e,
	}
}

func (e *DataError) Error() string {
	return e.err.Error()
}

func (e *DataError) Fields() map[string]any {
	return e.data
}

func (e *DataError) WithField(key string, value any) *DataError {
	return e.WithFields(map[string]any{key: value})
}

func (e *DataError) WithFields(values map[string]any) *DataError {
	data := make(map[string]any, len(e.data)+len(values))
	for k, v := range e.data {
		data[k] = v
	}

	for k, v := range values {
		if t := reflect.TypeOf(v); t != nil {
			switch {
			case t.Kind() == reflect.Func, t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Func:
				continue
			}
		}

		data[k] = v
	}

	return &DataError{
		err:   e.err,
		data:  data,
		cause: e.cause,
	}
}

func (e *DataError) WithCause(err error) *DataError {
	return &DataError{
		err:   e.err,
		data:  e.data,
		cause: err,
	}
}

func (e *DataError) Unwrap() error {
	if e.cause != nil {
		return e.cause
	}

	return e.err
}

func (e *DataError) Is(target error) bool {
	err, ok := target.(*DataError)
	if !ok {
		return false
	}

	if e.Error() != target.Error() {
		return false
	}

	for k, v := range err.Fields() {
		if e.Fields()[k] != v {
			return false
		}
	}

	return true
}


1		package errors
2
3		import (
4		"errors"
5		"fmt"
6		"reflect"
7		)
8
9		type DataError struct {
10		err error
11		data map[string]any
12		cause error
13		}
14
15		func New(text string) *DataError {
16	14	return &DataError{
17		err: errors.New(text),
18		}
19		}
20
21		func Newf(format string, v ...any) *DataError {
22	1001	return &DataError{
23		err: fmt.Errorf(format, v...),
24		}
25		}
26
27		func Wrap(err any) *DataError {
28	11	if err == nil {
29		return nil
30		}
31
32	11	var e error
33	11	switch t := err.(type) {
34		case *DataError:
35	5	return t
36		case error:
37	5	e = t
38		default:
39	1	e = fmt.Errorf("%v", err)
40		}
41
42	6	return &DataError{
43		err: e,
44		}
45		}
46
47		func (e *DataError) Error() string {
48	28	return e.err.Error()
49		}
50
51		func (e *DataError) Fields() map[string]any {
52	20	return e.data
53		}
54
55		func (e DataError) WithField(key string, value any) DataError {
56	15	return e.WithFields(map[string]any{key: value})
57		}
58
59		func (e DataError) WithFields(values map[string]any) DataError {
60	18	data := make(map[string]any, len(e.data)+len(values))
61	18	for k, v := range e.data {
62	6	data[k] = v
63		}
64
65	18	for k, v := range values {
66	18	if t := reflect.TypeOf(v); t != nil {
67	18	switch {
68		case t.Kind() == reflect.Func, t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Func:
69		continue
70		}
71		}
72
73	18	data[k] = v
74		}
75
76	18	return &DataError{
77		err: e.err,
78		data: data,
79		cause: e.cause,
80		}
81		}
82
83		func (e DataError) WithCause(err error) DataError {
84	1	return &DataError{
85		err: e.err,
86		data: e.data,
87		cause: err,
88		}
89		}
90
91		func (e *DataError) Unwrap() error {
92	12	if e.cause != nil {
93	1	return e.cause
94		}
95
96	11	return e.err
97		}
98
99		func (e *DataError) Is(target error) bool {
100	14	err, ok := target.(*DataError)
101	14	if !ok {
102	4	return false
103		}
104
105	10	if e.Error() != target.Error() {
106	2	return false
107		}
108
109	8	for k, v := range err.Fields() {
110	5	if e.Fields()[k] != v {
111	3	return false
112		}
113		}
114
115	5	return true
116		}
117

gravitton / errors

errors.*DataError.Is A last analyzed 2025-08-06 19:54 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

errors.*DataError.Is A
last analyzed 2025-08-06 19:54 UTC