Init package

Author: tomas-novotny

.github/workflows/main.yml

@@ -0,0 +1,43 @@
+name: Test
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Go ${{ matrix.go }}
+    strategy:
+      matrix:
+        go:
+          - '1.24'
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Go ${{ matrix.go }}
+        uses: actions/setup-go@v4
+        with:
+          go-version: ${{ matrix.go }}
+
+      - name: Install tools
+        run: |
+          go install honnef.co/go/tools/cmd/staticcheck@latest
+          go install golang.org/x/vuln/cmd/govulncheck@latest
+
+      - name: Vet
+        run: go vet ./...
+
+      - name: Lint
+        run: staticcheck ./...
+
+      - name: Security
+        run: govulncheck ./...
+
+      - name: Build
+        run: go build -v ./...
+
+      - name: Test
+        run: go test -v -race -coverprofile=coverage.out -covermode=atomic ./...

CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+
+## [Unreleased](https://github.com/gravitton/errors/compare/v0.1.0...master)
+
+
+## v0.1.0 (2025-08-03)
+### Added

LICENSE.md

@@ -0,0 +1,21 @@
+# The MIT License (MIT)
+
+Copyright (c) 2018 Tomáš Novotný <tomas.novotny.301@gmail.com>
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.

README.md

@@ -0,0 +1,44 @@
+# Errors
+
+[![Latest Stable Version][ico-release]][link-release]
+[![Build Status][ico-workflow]][link-workflow]
+[![Go Dev Reference][ico-go-dev-reference]][link-go-dev-reference]
+[![Software License][ico-license]][link-licence]
+
+
+## Installation
+
+```bash
+go get github.com/gravitton/errors
+```
+
+
+## Usage
+
+```go
+```
+
+
+## Credits
+
+- [Tomáš Novotný](https://github.com/tomas-novotny)
+- [All Contributors][link-contributors]
+
+
+## License
+
+The MIT License (MIT). Please see [License File][link-licence] for more information.
+
+
+[ico-license]:              https://img.shields.io/github/license/gravitton/errors.svg?style=flat-square&colorB=blue
+[ico-workflow]:             https://img.shields.io/github/actions/workflow/status/gravitton/errors/main.yml?branch=main&style=flat-square
+[ico-release]:              https://img.shields.io/github/v/release/gravitton/errors?style=flat-square&colorB=blue
+[ico-go-dev-reference]:     https://img.shields.io/badge/go.dev-reference-blue?style=flat-square
+
+[link-author]:              https://github.com/gravitton
+[link-release]:             https://github.com/gravitton/errors/releases
+[link-contributors]:        https://github.com/gravitton/errors/contributors
+[link-licence]:             ./LICENSE.md
+[link-changelog]:           ./CHANGELOG.md
+[link-workflow]:            https://github.com/gravitton/errors/actions
+[link-go-dev-reference]:    https://pkg.go.dev/github.com/gravitton/errors

doc.go

@@ -0,0 +1 @@
+package errors

error.go

@@ -0,0 +1,116 @@
+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
+}

error_test.go

@@ -0,0 +1,93 @@
+package errors
+
+import (
+	"errors"
+	"github.com/gravitton/assert"
+	"reflect"
+	"testing"
+)
+
+func TestFields(t *testing.T) {
+	err := Newf("Test DataError #%d: %s", 5, "failed to spawn")
+	assert.Equal(t, err.Error(), "Test DataError #5: failed to spawn")
+	assert.Length(t, err.Fields(), 0)
+
+	err = Wrap("test")
+	assert.Equal(t, err.Error(), "test")
+
+	err = New("test3").WithField("action", "call")
+	assert.Equal(t, err.Error(), "test3")
+	assert.Equal(t, err.Fields()["action"], "call")
+	assert.NotContains(t, err.Fields(), "type")
+
+	err1 := Wrap(err)
+	assert.Same(t, err, err1)
+
+	err2 := err.WithFields(map[string]any{"type": "warning"})
+	assert.NotSame(t, err1, err2)
+	assert.NotContains(t, err.Fields(), "type")
+	assert.Equal(t, err2.Fields()["type"], "warning")
+
+	err3 := err.WithField("action", "send")
+	assert.Equal(t, err2.Fields()["action"], "call")
+	assert.Equal(t, err3.Fields()["action"], "send")
+
+	err4 := New("error")
+	err5 := New("error")
+	assert.Equal(t, err4, err5)
+	assert.NotSame(t, err4, err5)
+}
+
+func TestUnwrap(t *testing.T) {
+	err := New("original error 1")
+
+	cause := err.Unwrap()
+
+	assert.Equal(t, reflect.TypeOf(cause).String(), "*errors.errorString")
+	assert.Equal(t, "original error 1", cause.Error())
+
+	oErr := errors.New("original error 2")
+	err = Wrap(oErr)
+
+	assert.Same(t, oErr, err.Unwrap())
+
+	oErr2 := errors.New("original error 3")
+	err = err.WithCause(oErr2)
+	assert.Same(t, oErr2, err.Unwrap())
+}
+
+func TestErrorsIs(t *testing.T) {
+	tests := []struct {
+		name string
+		err  error
+	}{
+		{
+			name: "*errors.errorString",
+			err:  errors.New("dummy error"),
+		},
+		{
+			name: "*DataError",
+			err:  New("dummy error"),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			assert.ErrorIs(t, test.err, test.err)
+			assert.ErrorIs(t, Wrap(test.err), test.err)
+			assert.ErrorIs(t, Wrap(test.err).WithField("action", "call"), test.err)
+			assert.ErrorIs(t, Wrap(test.err).WithField("action", "call").WithField("type", "warning"), test.err)
+			assert.ErrorIs(t, Wrap(test.err).WithFields(map[string]any{"type": "warning"}), test.err)
+		})
+	}
+}
+
+func TestErrorsIsWithFields(t *testing.T) {
+	assert.ErrorIs(t, New("dummy error").WithField("action", "call"), New("dummy error"))
+	assert.NotErrorIs(t, New("dummy error"), New("dummy error").WithField("action", "call"))
+	assert.NotErrorIs(t, New("dummy error").WithField("action", "call"), New("dummy error").WithField("action", "send"))
+
+	err := New("dummy error").WithField("module", "http")
+	assert.ErrorIs(t, err.WithField("add", false), err)
+	assert.NotErrorIs(t, err, err.WithField("add", false))
+}

go.mod

@@ -0,0 +1,5 @@
+module github.com/gravitton/errors
+
+go 1.24
+
+require github.com/gravitton/assert v0.1.0