errors

This is comprehensive, pretending to be close to real-life example of using this package. It's easier to see it in code, but if you use godoc, please, notice https://godoc.org/github.com/pashaosipyants/errors/example_auxiliary package, which is used here.

Imagine there is an api to create a task that is executed by another service. Besides user of this api wants to hold info whether this task is already done. This api, ofc, can return error. E.g. certain task may be already created. If so, error should report whether it is done or not.

package main

import (
	"bytes"
	"fmt"
	"os"

	"github.com/sirupsen/logrus"

	. "github.com/pashaosipyants/errors/v2"
	"github.com/pashaosipyants/errors/v2/example_auxiliary"
)

// This is comprehensive, pretending to be close to real-life example of using this package.
// It's easier to see it in code, but if you use godoc, please, notice
// https://godoc.org/github.com/pashaosipyants/errors/example_auxiliary package,
// which is used here.
//
// Imagine there is an api to create a task that is executed by another service.
// Besides user of this api wants to hold info whether this task is already done.
// This api, ofc, can return error. E.g. certain task may be already created.
// If so, error should report whether it is done or not.
func main() {
	l := logrus.New().WithField("application", "tasks")
	l.Logger.SetFormatter(TerminalVerbose{})
	l.Logger.SetOutput(os.Stdout)

	// loop to work out different cases
	for i := 0; i < 4; i++ {
		// func is smth like try block here
		func() {
			defer l.Infof("\n\tCase %d finished\n-------------------------------------------\n\n\n", i)

			// smth like catch block
			defer Handler(func(err error) {
				switch ValueE(err, "api") {
				case errcode_apicreatetaskfailed:
					logger, ok := ValueE(err, "logger").(*logrus.Entry) // logger with relevant fields of functions deeper in the call stack
					if !ok {
						logger = l
					}
					var ue *UserError
					if AsE(err, &ue) {
						logger = logger.WithField("user", ue.user)
					}
					logger.Error(SprintE(err)) // log
					// may be some specific actions
				case errcode_apiuserloginfailed:
					// may be some specific actions
					panic("Assertion failed") // but in our example can't be here
				default:
					panic("Assertion failed")
				}
			})

			Check(
				apiUserLogin(l), OValue("api", errcode_apiuserloginfailed))

			Check(
				apiCreateTask(l, i), OValue("api", errcode_apicreatetaskfailed))

			l.Info("Success!!!\n") // log
		}()
	}

}

const errcode_apicreatetaskfailed = "api_create_task_failed"
const errcode_apiuserloginfailed = "api_user_login_failed"

func apiCreateTask(l *logrus.Entry, i int) (reterr error) {
	defer Handler(func(err error) {
		// do some specific logic - e.g. mark task in db as done
		switch {
		case IsE(err, example_auxiliary.ErrTaskAlreadyExistButNotDone):
			errOnMark := markTaskAsDone()
			reterr = AnyE(
				WrapE(errOnMark, OSupp(err)),
				err,
			)
		default:
			reterr = err
		}
		// common logic
	})

	err := example_auxiliary.CreateTaskInitedByUser(l, i, 239)
	Check(WrapUserError(err, 239))

	return nil
}

// pretends to be always success
func apiUserLogin(l *logrus.Entry) error {
	// some work

	return nil
}

// pretends that there is an error an task can not be marked as done
func markTaskAsDone() (reterr error) {
	defer DefaultHandler(&reterr)
	CheckIf(true, Error("task can not be marked as done"))
	return
}

func WrapUserError(err error, user int) error {
	if err == nil {
		return nil
	}
	return &UserError{
		user: user,
		err:  err,
	}
}

type UserError struct {
	user int
	err  error
}

func (x *UserError) Error() string {
	return x.err.Error()
}

func (x *UserError) Unwrap() error {
	return x.err
}

func (x *UserError) Format(f fmt.State, verb rune) {
	if verb == 's' {
		fmt.Fprint(f, x.err.Error())
	} else {
		fmt.Fprintf(f, "User: %d; Error: %v", x.user, x.err)
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////

type TerminalVerbose struct {
}

const breaker = "........................................................\n"

func (t TerminalVerbose) Format(e *logrus.Entry) ([]byte, error) {
	if e.Level == logrus.InfoLevel {
		msg := lineBreaker(e.Message)
		return []byte(msg), nil
	}

	msg := lineBreaker(e.Message)

	var fields string
	for k, v := range e.Data {
		msg := fmt.Sprint(v)
		msg = lineBreaker(msg)
		fields += "--" + k + ":\n" + msg
	}

	var b *bytes.Buffer
	if e.Buffer != nil {
		b = e.Buffer
	} else {
		b = &bytes.Buffer{}
	}

	_, err := b.WriteString("\n" + breaker + msg + "\n" + fields)
	if err != nil {
		return nil, err
	}

	return b.Bytes(), nil
}

func lineBreaker(in string) string {
	if len(in) > 0 && in[len(in)-1] != '\n' {
		in += "\n"
	}
	return in
}

Output:

wrong output specially to make this function be executed and see output of this example