hpatch/failure.go at main · yusing/hpatch · GitHub

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
package hpatch

import "errors"

type targetVariant uint8

const (
	targetVariantNone targetVariant = iota
	targetVariantLine
	targetVariantRange
	targetVariantTextSingle
	targetVariantTextMultiple
)

const targetVariantCount = 4

var targetVariantNames = [targetVariantCount]string{"line", "range", "text-single", "text-multiple"}

type failureReason uint8

const (
	reasonSyntax failureReason = iota
	reasonRowMissing
	reasonRowStale
	reasonOccurrenceMissing
	reasonInvalidCount
	reasonTargetOrder
	reasonEditConflict
	reasonActiveFile
	reasonInitialization
	reasonFilePath
	reasonLanguageSyntax
	reasonOther
	failureReasonCount
)

// Existing filesystem failures share the public HPATCH/2 file-path reason.
const (
	reasonFileMissing  = reasonFilePath
	reasonFileConflict = reasonFilePath
	reasonPath         = reasonFilePath
)

var failureReasonNames = [failureReasonCount]string{
	"script-syntax",
	"row-missing",
	"row-stale",
	"occurrence-missing",
	"invalid-count",
	"target-order",
	"edit-conflict",
	"active-file",
	"initialization",
	"file-path",
	"language-syntax",
	"other",
}

type reasonedError struct {
	reason failureReason
	err    error
}

func (e *reasonedError) Error() string { return e.err.Error() }
func (e *reasonedError) Unwrap() error { return e.err }

func withReason(reason failureReason, err error) error {
	if err == nil {
		return nil
	}
	return &reasonedError{reason: reason, err: err}
}

func reasonOf(err error, fallback failureReason) failureReason {
	if classified, ok := errors.AsType[*reasonedError](err); ok {
		return classified.reason
	}
	if command, ok := errors.AsType[*commandError](err); ok {
		return command.Reason
	}
	return fallback
}