aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/gopkg.in/urfave/cli.v1/errors.go
blob: 0206ff491189ed99473527647366be7c6382d390 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
package cli

import (
    "fmt"
    "io"
    "os"
    "strings"
)

// OsExiter is the function used when the app exits. If not set defaults to os.Exit.
var OsExiter = os.Exit

// ErrWriter is used to write errors to the user. This can be anything
// implementing the io.Writer interface and defaults to os.Stderr.
var ErrWriter io.Writer = os.Stderr

// MultiError is an error that wraps multiple errors.
type MultiError struct {
    Errors []error
}

// NewMultiError creates a new MultiError. Pass in one or more errors.
func NewMultiError(err ...error) MultiError {
    return MultiError{Errors: err}
}

// Error implements the error interface.
func (m MultiError) Error() string {
    errs := make([]string, len(m.Errors))
    for i, err := range m.Errors {
        errs[i] = err.Error()
    }

    return strings.Join(errs, "\n")
}

type ErrorFormatter interface {
    Format(s fmt.State, verb rune)
}

// ExitCoder is the interface checked by `App` and `Command` for a custom exit
// code
type ExitCoder interface {
    error
    ExitCode() int
}

// ExitError fulfills both the builtin `error` interface and `ExitCoder`
type ExitError struct {
    exitCode int
    message  interface{}
}

// NewExitError makes a new *ExitError
func NewExitError(message interface{}, exitCode int) *ExitError {
    return &ExitError{
        exitCode: exitCode,
        message:  message,
    }
}

// Error returns the string message, fulfilling the interface required by
// `error`
func (ee *ExitError) Error() string {
    return fmt.Sprintf("%v", ee.message)
}

// ExitCode returns the exit code, fulfilling the interface required by
// `ExitCoder`
func (ee *ExitError) ExitCode() int {
    return ee.exitCode
}

// HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
// so prints the error to stderr (if it is non-empty) and calls OsExiter with the
// given exit code.  If the given error is a MultiError, then this func is
// called on all members of the Errors slice.
func HandleExitCoder(err error) {
    if err == nil {
        return
    }

    if exitErr, ok := err.(ExitCoder); ok {
        if err.Error() != "" {
            if _, ok := exitErr.(ErrorFormatter); ok {
                fmt.Fprintf(ErrWriter, "%+v\n", err)
            } else {
                fmt.Fprintln(ErrWriter, err)
            }
        }
        OsExiter(exitErr.ExitCode())
        return
    }

    if multiErr, ok := err.(MultiError); ok {
        for _, merr := range multiErr.Errors {
            HandleExitCoder(merr)
        }
        return
    }

    if err.Error() != "" {
        if _, ok := err.(ErrorFormatter); ok {
            fmt.Fprintf(ErrWriter, "%+v\n", err)
        } else {
            fmt.Fprintln(ErrWriter, err)
        }
    }
    OsExiter(1)
}