User-facing errors in example runner

internal/errs/centralized.go

@@ -0,0 +1,5 @@
+package errs
+
+type ErrNoProject struct {
+	*WrapperError
+}

internal/errs/errs.go

@@ -36,6 +36,33 @@ type TransientError interface {
 	IsTransient()
 }
 
+type UserFacingError interface {
+	error
+	UserError() string
+}
+
+type userFacingError struct {
+	wrapped error
+	message string
+	tips    []string
+}
+
+func (e *userFacingError) Error() string {
+	return JoinMessage(Wrap(e.wrapped, e.message))
+}
+
+func (e *userFacingError) UserError() string {
+	return e.message
+}
+
+func (e *userFacingError) AddTips(tips ...string) {
+	e.tips = append(e.tips, tips...)
+}
+
+func (e *userFacingError) ErrorTips() []string {
+	return e.tips
+}
+
 // PackedErrors represents a collection of errors that aren't necessarily related to each other
 // note that rtutils replicates this functionality to avoid import cycles
 type PackedErrors struct {
@@ -104,6 +131,22 @@ func Wrap(wrapTarget error, message string, args ...interface{}) *WrapperError {
 	return newError(msg, wrapTarget)
 }
 
+func NewUserFacingError(message string, args ...interface{}) *userFacingError {
+	return &userFacingError{
+		nil,
+		fmt.Sprintf(message, args...),
+		nil,
+	}
+}
+
+func WrapUserFacingError(wrapTarget error, message string, args ...interface{}) *userFacingError {
+	return &userFacingError{
+		wrapTarget,
+		fmt.Sprintf(message, args...),
+		nil,
+	}
+}
+
 // Pack creates a new error that packs the given errors together, allowing for multiple errors to be returned
 func Pack(err error, errs ...error) error {
 	return &PackedErrors{append([]error{err}, errs...)}
@@ -258,3 +301,14 @@ func Unpack(err error) []error {
 	}
 	return result
 }
+
+// IsUserFacing identifies whether this error was curated for end-users and
+// returns that error. This is NOT the same as an error that is localized.
+func IsUserFacing(err error) (error, bool) {
+	var userFacingError UserFacingError
+	if errors.As(err, &userFacingError) {
+		return userFacingError, true
+	}
+
+	return err, false
+}

internal/runbits/hello_example.go

@@ -1,14 +1,19 @@
 package runbits
 
 import (
+	"github.com/ActiveState/cli/internal/errs"
 	"github.com/ActiveState/cli/internal/locale"
 	"github.com/ActiveState/cli/internal/output"
 )
 
+type NoNameProvidedError struct {
+	*errs.WrapperError
+}
+
 func SayHello(out output.Outputer, name string) error {
 	if name == "" {
 		// Errors that are due to USER input should use `NewInputError` or `WrapInputError`
-		return locale.NewInputError("hello_err_no_name", "No name provided.")
+		return &NoNameProvidedError{errs.New("No name provided.")}
 	}
 
 	out.Print(locale.Tl("hello_message", "Hello, {{.V0}}!", name))

internal/runners/hello/hello_example.go

@@ -37,9 +37,7 @@ type RunParams struct {
 // can be set. If no default or construction-time values are necessary, direct
 // construction of RunParams is fine, and this construction func may be dropped.
 func NewRunParams() *RunParams {
-	return &RunParams{
-		Name: "Friend",
-	}
+	return &RunParams{}
 }
 
 // Hello defines the app-level dependencies that are accessible within the Run
@@ -58,29 +56,48 @@ func New(p primeable) *Hello {
 	}
 }
 
+// processError contains the scope in which errors are processed. This is
+// useful for ensuring that errors are wrapped in a user-facing error and
+// localized.
+func processError(err *error) {
+	if err != nil {
+		switch {
+		case errs.Matches(*err, &runbits.NoNameProvidedError{}):
+			// Errors that we are looking for should be wrapped in a user-facing error.
+			// Ensure we wrap the top-level error returned from the runner and not
+			// the unpacked error that we are inspecting.
+			*err = errs.WrapUserFacingError(*err, locale.Tl("hello_err_no_name", "Cannot say hello because no name was provided."))
+		case errs.Matches(*err, &errs.ErrNoProject{}):
+			werr := errs.WrapUserFacingError(*err, locale.Tl("hello_err_no_project", "Cannot say hello because you are not in a project directory."))
+
+			// It's useful to offer users reasonable tips on recourses.
+			*err = errs.AddTips(werr, locale.Tl(
+				"hello_suggest_checkout",
+				"Try using [ACTIONABLE]`state checkout`[/RESET] first.",
+			))
+		}
+
+		*err = errs.Wrap(*err, "Cannot say hello")
+	}
+}
+
 // Run contains the scope in which the hello runner logic is executed.
-func (h *Hello) Run(params *RunParams) error {
+func (h *Hello) Run(params *RunParams) (rerr error) {
+	defer processError(&rerr)
+
 	h.out.Print(locale.Tl("hello_notice", "This command is for example use only"))
 
 	if h.project == nil {
-		err := locale.NewInputError(
-			"hello_info_err_no_project", "Not in a project directory.",
-		)
-
-		// It's useful to offer users reasonable tips on recourses.
-		return errs.AddTips(err, locale.Tl(
-			"hello_suggest_checkout",
-			"Try using [ACTIONABLE]`state checkout`[/RESET] first.",
-		))
+		return &errs.ErrNoProject{errs.New("Not in a project directory")}
 	}
 
 	// Reusable runner logic is contained within the runbits package.
 	// You should only use this if you intend to share logic between
 	// runners. Runners should NEVER invoke other runners.
 	if err := runbits.SayHello(h.out, params.Name); err != nil {
 		// Errors should nearly always be localized.
-		return locale.WrapError(
-			err, "hello_cannot_say", "Cannot say hello.",
+		return errs.Wrap(
+			err, "Cannot say hello.",
 		)
 	}
 
@@ -98,8 +115,8 @@ func (h *Hello) Run(params *RunParams) error {
 	// Grab data from the platform.
 	commitMsg, err := currentCommitMessage(h.project)
 	if err != nil {
-		err = locale.WrapError(
-			err, "hello_info_err_get_commit_msg", " Cannot get commit message",
+		err = errs.Wrap(
+			err, "Cannot get commit message",
 		)
 		return errs.AddTips(
 			err,
@@ -127,9 +144,7 @@ func currentCommitMessage(proj *project.Project) (string, error) {
 
 	commit, err := model.GetCommit(proj.CommitUUID())
 	if err != nil {
-		return "", locale.NewError(
-			"hello_info_err_get_commitr", "Cannot get commit from server",
-		)
+		return "", errs.Wrap(err, "Cannot get commit from server")
 	}
 
 	commitMsg := locale.Tl("hello_info_warn_no_commit", "Commit description not provided.")

pkg/cmdlets/errors/errors.go

@@ -98,11 +98,21 @@ func ParseUserFacing(err error) (int, error) {
 	// unwrap exit code before we remove un-localized wrapped errors from err variable
 	code := errs.ParseExitCode(err)
 
+	// If there is a user facing error in the error stack we want to ensure
+	// that is it forwarded to the user.
+	uerr, ok := errs.IsUserFacing(err)
+	if ok {
+		logging.Debug("Returning user facing error, error stack: \n%s", errs.JoinMessage(err))
+		return code, &OutputError{uerr}
+	}
+
 	if errs.IsSilent(err) {
 		logging.Debug("Suppressing silent failure: %v", err.Error())
 		return code, nil
 	}
 
+	// If the error already has a marshalling function we do not want to wrap
+	// it again in the OutputError type.
 	if hasMarshaller {
 		return code, err
 	}