Gradle error enhancements

internal/resolution/job/error.go

@@ -5,16 +5,19 @@ type IError interface {
 	Command() string
 	Documentation() string
 	Status() string
+	IsCritical() bool
 	SetStatus(string)
 	SetDocumentation(string)
 	SetCommand(string)
+	SetIsCritical(bool)
 }
 
 type BaseJobError struct {
 	err           string
 	command       string
 	documentation string
 	status        string
+	isCritical    bool
 }
 
 func (e BaseJobError) Error() string {
@@ -33,6 +36,10 @@ func (e BaseJobError) Status() string {
 	return e.status
 }
 
+func (e BaseJobError) IsCritical() bool {
+	return e.isCritical
+}
+
 func (e *BaseJobError) SetStatus(status string) {
 	e.status = status
 }
@@ -45,11 +52,16 @@ func (e *BaseJobError) SetCommand(command string) {
 	e.command = command
 }
 
+func (e *BaseJobError) SetIsCritical(isCritical bool) {
+	e.isCritical = isCritical
+}
+
 func NewBaseJobError(err string) *BaseJobError {
 	return &BaseJobError{
 		err:           err,
 		command:       "",
 		documentation: "",
 		status:        "",
+		isCritical:    true,
 	}
 }

internal/resolution/job/errors.go

@@ -3,6 +3,7 @@ package job
 type IErrors interface {
 	Warning(err IError)
 	Critical(err IError)
+	Append(err IError)
 	GetWarningErrors() []IError
 	GetCriticalErrors() []IError
 	GetAll() []IError
@@ -31,6 +32,14 @@ func (errors *Errors) Critical(err IError) {
 	errors.criticalErrs = append(errors.criticalErrs, err)
 }
 
+func (errors *Errors) Append(err IError) {
+	if err.IsCritical() {
+		errors.Critical(err)
+	} else {
+		errors.Warning(err)
+	}
+}
+
 func (errors *Errors) GetWarningErrors() []IError {
 	return errors.warningErrs
 }

internal/resolution/job/errors_test.go

@@ -33,6 +33,27 @@ func TestCritical(t *testing.T) {
 	assert.Contains(t, errors.criticalErrs, critical)
 }
 
+func TestAppend(t *testing.T) {
+	errors := NewErrors("")
+
+	critical1 := NewBaseJobError("critical")
+	critical1.SetIsCritical(true)
+	errors.Append(critical1)
+
+	critical2 := NewBaseJobError("another critical")
+	errors.Append(critical2)
+
+	warning := NewBaseJobError("warning")
+	warning.SetIsCritical(false)
+	errors.Append(warning)
+
+	assert.Len(t, errors.warningErrs, 1)
+	assert.Len(t, errors.criticalErrs, 2)
+	assert.Contains(t, errors.criticalErrs, critical1)
+	assert.Contains(t, errors.criticalErrs, critical2)
+	assert.Contains(t, errors.warningErrs, warning)
+}
+
 func TestGetWarningErrors(t *testing.T) {
 	errors := NewErrors("")
 	warning := NewBaseJobError("error")

internal/resolution/pm/gradle/job.go

@@ -3,13 +3,21 @@ package gradle
 import (
 	"fmt"
 	"path/filepath"
+	"regexp"
 	"strings"
 
 	"github.com/debricked/cli/internal/resolution/job"
 	"github.com/debricked/cli/internal/resolution/pm/util"
 	"github.com/debricked/cli/internal/resolution/pm/writer"
 )
 
+const (
+	bugErrRegex             = "BUG! (.*)"
+	notRootDirErrRegex      = "Error: (Could not find or load main class .*)"
+	unrelatedBuildErrRegex  = "(Project directory '.*' is not part of the build defined by settings file '.*')"
+	unknownPropertyErrRegex = "(Could not get unknown property .*)"
+)
+
 type Job struct {
 	job.BaseJob
 	dir              string
@@ -53,22 +61,29 @@ func (j *Job) Run() {
 
 	if err != nil {
 		if permissionErr != nil {
-			j.Errors().Critical(util.NewPMJobError(permissionErr.Error()))
+			j.handleError(util.NewPMJobError(permissionErr.Error()))
 		}
-		j.Errors().Critical(util.NewPMJobError(err.Error()))
+		cmdErr := util.NewPMJobError(err.Error())
+		cmdErr.SetCommand(strings.Trim(dependenciesCmd.String(), " "))
+		j.handleError(cmdErr)
 
 		return
 	}
 
-	j.SendStatus("creating dependency graph")
+	status := "creating dependency graph"
+	j.SendStatus(status)
 	_, err = dependenciesCmd.Output()
 
 	if permissionErr != nil {
-		j.Errors().Warning(util.NewPMJobError(permissionErr.Error()))
+		cmdErr := util.NewPMJobError(permissionErr.Error())
+		cmdErr.SetIsCritical(false)
+		j.handleError(cmdErr)
 	}
 
 	if err != nil {
-		j.Errors().Critical(util.NewPMJobError(j.GetExitError(err).Error()))
+		cmdErr := util.NewPMJobError(j.GetExitError(err).Error())
+		cmdErr.SetCommand(dependenciesCmd.String())
+		j.handleError(cmdErr)
 
 		return
 	}
@@ -77,3 +92,127 @@ func (j *Job) Run() {
 func (j *Job) GetDir() string {
 	return j.dir
 }
+
+func (j *Job) handleError(cmdErr job.IError) {
+	expressions := []string{
+		bugErrRegex,
+		notRootDirErrRegex,
+		unrelatedBuildErrRegex,
+		unknownPropertyErrRegex,
+	}
+
+	for _, expression := range expressions {
+		regex := regexp.MustCompile(expression)
+
+		if regex.MatchString(cmdErr.Error()) {
+			cmdErr = j.addDocumentation(expression, regex, cmdErr)
+			j.Errors().Append(cmdErr)
+
+			return
+		}
+	}
+
+	j.Errors().Append(cmdErr)
+}
+
+func (j *Job) addDocumentation(expr string, regex *regexp.Regexp, cmdErr job.IError) job.IError {
+	switch {
+	case expr == bugErrRegex:
+		cmdErr = j.addBugErrorDocumentation(regex, cmdErr)
+	case expr == notRootDirErrRegex:
+		cmdErr = j.addNotRootDirErrorDocumentation(regex, cmdErr)
+	case expr == unrelatedBuildErrRegex:
+		cmdErr = j.addUnrelatedBuildErrorDocumentation(regex, cmdErr)
+	case expr == unknownPropertyErrRegex:
+		cmdErr = j.addUnknownPropertyErrorDocumentation(regex, cmdErr)
+	}
+
+	return cmdErr
+}
+
+func (j *Job) addBugErrorDocumentation(regex *regexp.Regexp, cmdErr job.IError) job.IError {
+	matches := regex.FindAllStringSubmatch(cmdErr.Error(), 1)
+	message := ""
+	if len(matches) > 0 && len(matches[0]) > 1 {
+		message = matches[0][1]
+	}
+
+	cmdErr.SetDocumentation(
+		strings.Join(
+			[]string{
+				"Failed to build Gradle dependency tree. ",
+				"The process has failed with following error: ",
+				message,
+				". ",
+				"Try running the command below with --stacktrace flag to get a stacktrace. ",
+				"Replace --stacktrace with --info or --debug option to get more log output. ",
+				"Or with --scan to get full insights.",
+			}, ""),
+	)
+
+	return cmdErr
+}
+
+func (j *Job) addNotRootDirErrorDocumentation(regex *regexp.Regexp, cmdErr job.IError) job.IError {
+	matches := regex.FindAllStringSubmatch(cmdErr.Error(), 1)
+	message := ""
+	if len(matches) > 0 && len(matches[0]) > 1 {
+		message = matches[0][1]
+	}
+
+	cmdErr.SetDocumentation(
+		strings.Join(
+			[]string{
+				"Failed to build Gradle dependency tree.",
+				"The process has failed with following error: " + message + ".", //nolint:all
+				"You are probably not running the command from the root directory.",
+			}, " "),
+	)
+
+	return cmdErr
+}
+
+func (j *Job) addUnrelatedBuildErrorDocumentation(regex *regexp.Regexp, cmdErr job.IError) job.IError {
+	matches := regex.FindAllStringSubmatch(cmdErr.Error(), 1)
+	message := ""
+	if len(matches) > 0 && len(matches[0]) > 1 {
+		message = matches[0][1]
+	}
+
+	cmdErr.SetDocumentation(
+		strings.Join(
+			[]string{
+				"Failed to build Gradle dependency tree. ",
+				"The process has failed with following error: ",
+				message,
+				". ",
+				"This error might be caused by inclusion of test folders into resolve process. ",
+				"Try running resolve command with -e flag. ",
+				"For example, `debricked resolve -e \"**/test*/**\"` will exclude all folders that start from 'test' from resolution process. ",
+				"Or if this is an unrelated build, it must have its own settings file.",
+			}, ""),
+	)
+
+	return cmdErr
+}
+
+func (j *Job) addUnknownPropertyErrorDocumentation(regex *regexp.Regexp, cmdErr job.IError) job.IError {
+	matches := regex.FindAllStringSubmatch(cmdErr.Error(), 1)
+	message := ""
+	if len(matches) > 0 && len(matches[0]) > 1 {
+		message = matches[0][1]
+	}
+
+	cmdErr.SetDocumentation(
+		strings.Join(
+			[]string{
+				"Failed to build Gradle dependency tree. ",
+				"The process has failed with following error: ",
+				message,
+				". ",
+				"Please check your settings.gradle file for errors.",
+			}, ""),
+	)
+
+	return cmdErr
+}