add errors/ package

Author: cppforlife

README.md

@@ -2,6 +2,10 @@
 
 Originally this library was written for [BOSH CLI v2](http://bosh.io/docs/cli-v2.html). Given its generic nature, it's been extracted as a separate, easily importable library.
 
+- `errors` package: helps a bit with formatting of errors
+- `ui` package: helps with printing CLI content
+  - `table` package: helps format CLI content as a table
+
 Examples:
 
-- [Table](examples/table.go)
+- [Table](examples/table/main.go)

errors/error_piece.go

@@ -0,0 +1,227 @@
+package errors
+
+import (
+	"regexp"
+	"strings"
+)
+
+const (
+	braketOpen = "["
+	parenOpen  = "("
+	curlyOpen  = "{"
+	rootOpen   = "*"
+	customOpen = "~"
+	rawOpen    = "...|"
+
+	braketClose = "]"
+	parenClose  = ")"
+	curlyClose  = "}"
+	rawClose    = "|..."
+)
+
+var (
+	sepOpeners = map[string]string{
+		braketOpen: string(braketOpen),
+		parenOpen:  string(parenOpen),
+		curlyOpen:  string(curlyOpen),
+		rootOpen:   "",
+		customOpen: "",
+		rawOpen:    "",
+	}
+	sepClosers = map[string]string{
+		braketOpen: string(braketClose),
+		parenOpen:  string(parenClose),
+		curlyOpen:  string(curlyClose),
+		rootOpen:   "",
+		customOpen: "",
+		rawOpen:    "",
+	}
+)
+
+type ErrorPiece struct {
+	Value string
+
+	ContainerType string // eg *,{,[,(
+	Pieces        []*ErrorPiece
+
+	ReorganizePiecesAroundCommas bool
+	FormatPiecesAsList           bool
+}
+
+func NewErrorPiecesFromString(str string) (*ErrorPiece, bool) {
+	rootPiece := &ErrorPiece{
+		ContainerType: rootOpen,
+	}
+	stack := []*ErrorPiece{rootPiece}
+
+	for i, f := range str {
+		if len(stack) == 0 {
+			return rootPiece, false
+		}
+
+		charStr := string(f)
+
+		if !stack[len(stack)-1].IsLeafContainer() {
+			switch charStr {
+			case braketOpen, curlyOpen, parenOpen:
+				piece := &ErrorPiece{ContainerType: charStr}
+				stack[len(stack)-1].AddPiece(piece)
+				stack = append(stack, piece)
+				continue
+
+			case braketClose, curlyClose, parenClose:
+				stack = stack[:len(stack)-1]
+				continue
+			}
+		}
+
+		switch {
+		case checkForward(str, i, rawOpen):
+			piece := &ErrorPiece{ContainerType: rawOpen}
+			piece.AddStr(charStr)
+			stack[len(stack)-1].AddPiece(piece)
+			stack = append(stack, piece)
+
+		case checkBackward(str, i, rawClose):
+			stack[len(stack)-1].AddStr(charStr)
+			stack = stack[:len(stack)-1]
+
+		default:
+			stack[len(stack)-1].AddStr(charStr)
+		}
+	}
+
+	return rootPiece, len(stack) == 1
+}
+
+func checkForward(str string, i int, sep string) bool {
+	endIdx := i + len(sep)
+	if endIdx < len(str) {
+		return str[i:endIdx] == sep
+	}
+	return false
+}
+
+func checkBackward(str string, i int, sep string) bool {
+	startIdx := i - len(sep) + 1
+	if startIdx >= 0 && i < len(str) {
+		return str[startIdx:i+1] == sep
+	}
+	return false
+}
+
+func (p *ErrorPiece) IsContainer() bool {
+	return len(p.ContainerType) > 0
+}
+
+func (p *ErrorPiece) IsLeafContainer() bool {
+	return p.ContainerType == rawOpen
+}
+
+func (p *ErrorPiece) AddPiece(piece *ErrorPiece) {
+	p.Pieces = append(p.Pieces, piece)
+}
+
+func (p *ErrorPiece) AddStr(str string) {
+	var lastPiece *ErrorPiece
+	if len(p.Pieces) > 0 {
+		lastPiece = p.Pieces[len(p.Pieces)-1]
+	}
+	if lastPiece == nil || lastPiece.IsContainer() {
+		lastPiece = &ErrorPiece{}
+		p.Pieces = append(p.Pieces, lastPiece)
+	}
+	lastPiece.Value += str
+}
+
+var (
+	listItemSep         = ", "
+	likelyListItemStart = regexp.MustCompile(`^[a-z\.\[\]:\s]{3,10}`)
+)
+
+func (p *ErrorPiece) ReorganizePieces() {
+	for _, piece := range p.Pieces {
+		piece.ReorganizePieces()
+	}
+
+	if p.ReorganizePiecesAroundCommas {
+		p.ReorganizePiecesAroundCommas = false
+
+		var newPieces []*ErrorPiece
+
+		for _, piece := range p.Pieces {
+			switch {
+			case len(piece.Value) > 0:
+				for i, val := range strings.Split(piece.Value, listItemSep) {
+					switch {
+					case len(newPieces) > 0 && i == 0:
+						newPieces[len(newPieces)-1].AddStr(val)
+
+					case len(newPieces) > 0 && !likelyListItemStart.MatchString(val):
+						newPieces[len(newPieces)-1].AddStr(listItemSep + val)
+
+					default:
+						newPieces = append(newPieces, &ErrorPiece{
+							ContainerType: customOpen,
+							Pieces:        []*ErrorPiece{{Value: val}},
+						})
+					}
+				}
+
+			case p.IsContainer():
+				if len(newPieces) > 0 {
+					newPieces[len(newPieces)-1].AddPiece(piece)
+				} else {
+					newPieces = append(newPieces, &ErrorPiece{
+						ContainerType: customOpen,
+						Pieces:        []*ErrorPiece{piece},
+					})
+				}
+			}
+		}
+
+		if len(newPieces) > 1 {
+			p.Pieces = newPieces
+			p.FormatPiecesAsList = true
+		}
+	}
+}
+
+func (p *ErrorPiece) AsString() string {
+	if len(p.Value) > 0 {
+		return p.Value
+	}
+
+	var result string
+
+	if p.FormatPiecesAsList {
+		if len(p.Pieces) > 0 {
+			result += "\n\n"
+		}
+		for _, piece := range p.Pieces {
+			result += "  - " + piece.AsString() + "\n\n"
+		}
+	} else {
+		result += sepOpeners[p.ContainerType]
+		for _, piece := range p.Pieces {
+			result += piece.AsString()
+		}
+		result += sepClosers[p.ContainerType]
+	}
+
+	return result
+}
+
+func (p *ErrorPiece) AsIndentedString(indent string) string {
+	if len(p.Value) > 0 {
+		return indent + "+ " + p.Value + "\n"
+	}
+	var result string
+	if p.IsContainer() {
+		result += indent + "+ ...\n"
+	}
+	for _, piece := range p.Pieces {
+		result += piece.AsIndentedString(indent + "  ")
+	}
+	return result
+}

errors/multi_line_error.go

@@ -0,0 +1,51 @@
+package errors
+
+import (
+	"regexp"
+	"strings"
+)
+
+var (
+	errColonSep = regexp.MustCompile("(: )([A-Z])")
+)
+
+type MultiLineError struct {
+	err error
+}
+
+func NewMultiLineError(err error) MultiLineError {
+	return MultiLineError{err}
+}
+
+func (e MultiLineError) Error() (result string) {
+	// Be conservative in not swallowing underlying error if any
+	// error processing fails (shouldn't happen, but let's be certain)
+	defer func() {
+		if rec := recover(); rec != nil {
+			result = e.err.Error()
+		}
+	}()
+
+	lines := strings.Split(e.err.Error(), "\n")
+
+	firstLineRootPiece, complete := NewErrorPiecesFromString(lines[0])
+	if !complete {
+		return e.err.Error() // cannot deconstruct error message, return original
+	}
+
+	for _, piece := range firstLineRootPiece.Pieces {
+		// Do not split withing container pieces
+		if len(piece.Value) > 0 {
+			piece.Value = errColonSep.ReplaceAllString(piece.Value, ":\n$2")
+		}
+	}
+
+	var firstLines []string
+	for i, chunk := range strings.Split(firstLineRootPiece.AsString(), "\n") {
+		firstLines = append(firstLines, strings.Repeat("  ", i)+chunk)
+	}
+
+	lines[0] = strings.Join(firstLines, "\n")
+
+	return strings.Join(lines, "\n")
+}

errors/mutli_line_error_test.go

@@ -0,0 +1,67 @@
+package errors_test
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/cppforlife/go-cli-ui/errors"
+)
+
+func TestMultiLineError(t *testing.T) {
+	tests := []multiLineErrorTest{
+		{
+			Description: "single line error",
+			Actual:      `Applying create deployment/frontend (apps/v1) namespace: default: Creating resource deployment/frontend (apps/v1) namespace: default: Deployment.apps "frontend" is invalid: spec.template.metadata.labels: Invalid value: map[string]string{"app":"guestbook", "kapp.k14s.io/app":"1588343775866234000", "kapp.k14s.io/association":"v1.95c1511bde234f3b1296c5e2be3c6864", "tier":"frontend"}: selector does not match template labels (reason: Invalid)`,
+			Expected: `
+Applying create deployment/frontend (apps/v1) namespace: default:
+  Creating resource deployment/frontend (apps/v1) namespace: default:
+    Deployment.apps "frontend" is invalid: spec.template.metadata.labels:
+      Invalid value: map[string]string{"app":"guestbook", "kapp.k14s.io/app":"1588343775866234000", "kapp.k14s.io/association":"v1.95c1511bde234f3b1296c5e2be3c6864", "tier":"frontend"}: selector does not match template labels (reason: Invalid)
+`,
+		},
+		{
+			Description: "multi line error",
+			Actual: `
+Applying create deployment/frontend (apps/v1) namespace: default: Creating resource deployment/frontend (apps/v1) namespace: default: Job.batch "successful-job" is invalid: 
+
+  - spec.selector: Invalid value: v1.LabelSelector{MatchLabels:map[string]string{"blah":"balh", "controller-uid":"374ab0c4-8a21-4a9b-b814-fe85cf99a69a"}, MatchExpressions:[]v1.LabelSelectorRequirement(nil)}: selector not auto-generated
+
+  - spec.template.spec.restartPolicy: Unsupported value: "Always": supported values: "OnFailure", "Never"
+
+ (reason: Invalid)
+`,
+			Expected: `
+Applying create deployment/frontend (apps/v1) namespace: default:
+  Creating resource deployment/frontend (apps/v1) namespace: default:
+    Job.batch "successful-job" is invalid: 
+
+  - spec.selector: Invalid value: v1.LabelSelector{MatchLabels:map[string]string{"blah":"balh", "controller-uid":"374ab0c4-8a21-4a9b-b814-fe85cf99a69a"}, MatchExpressions:[]v1.LabelSelectorRequirement(nil)}: selector not auto-generated
+
+  - spec.template.spec.restartPolicy: Unsupported value: "Always": supported values: "OnFailure", "Never"
+
+ (reason: Invalid)
+`,
+		},
+	}
+
+	for _, test := range tests {
+		test.Check(t)
+	}
+}
+
+type multiLineErrorTest struct {
+	Description string
+	Actual      string
+	Expected    string
+}
+
+func (e multiLineErrorTest) Check(t *testing.T) {
+	apiErr := errors.NewMultiLineError(fmt.Errorf("%s", strings.TrimSpace(e.Actual)))
+	e.Expected = strings.TrimSpace(e.Expected)
+
+	if apiErr.Error() != e.Expected {
+		t.Fatalf("(%s) expected error to match:\n%d chars >>>%s<<< vs \n%d chars >>>%s<<<",
+			e.Description, len(apiErr.Error()), apiErr, len(e.Expected), e.Expected)
+	}
+}

errors/semi_structured_error.go

@@ -0,0 +1,37 @@
+package errors
+
+type SemiStructuredError struct {
+	err error
+}
+
+func NewSemiStructuredError(err error) SemiStructuredError {
+	return SemiStructuredError{err}
+}
+
+func (e SemiStructuredError) Error() (result string) {
+	// Be conservative in not swallowing underlying error if any
+	// error processing fails (shouldn't happen, but let's be certain)
+	defer func() {
+		if rec := recover(); rec != nil {
+			result = e.err.Error()
+		}
+	}()
+
+	rootPiece, complete := NewErrorPiecesFromString(e.err.Error())
+	if !complete {
+		// Cannot deconstruct error message, return original
+		return e.err.Error()
+	}
+
+	for _, piece := range rootPiece.Pieces {
+		// k8s list of errors is wrapped with [] and separated by comma
+		// (https://github.com/kubernetes/kubernetes/blob/a5e6ac0a959b059513c1e7908fbb0713467839c4/staging/src/k8s.io/apimachinery/pkg/util/errors/errors.go#L64)
+		if piece.ContainerType == braketOpen {
+			piece.ReorganizePiecesAroundCommas = true
+		}
+	}
+
+	rootPiece.ReorganizePieces()
+
+	return rootPiece.AsString()
+}