better gui refreshing with event dispatcher and minor refacotrs on gui

10 files changed, 90 insertions, 149 deletions

diff --git a/pkg/gui/authenticationview.go b/pkg/gui/authenticationview.go
index 9c830cd..b644b6b 100644
--- a/pkg/gui/authenticationview.go
+++ b/pkg/gui/authenticationview.go
@@ -37,7 +37,7 @@ func (gui *Gui) openAuthenticationView(g *gocui.Gui, jobQueue *git.JobQueue, job
 		return err
 	}
 	jobRequiresAuth = job
-	if job.Entity.State != git.Fail {
+	if job.Entity.State() != git.Fail {
 		if err := jobQueue.RemoveFromQueue(job.Entity); err != nil {
 			log.Fatal(err.Error())
 			return err
@@ -96,7 +96,7 @@ func (gui *Gui) submitAuthenticationView(g *gocui.Gui, v *gocui.View) error {
 		}
 	case git.PullJob:
 		// we handle pull as fetch&merge so same rule applies
-		jobRequiresAuth.Options = git.FetchOptions{
+		jobRequiresAuth.Options = git.PullOptions{
 			RemoteName: jobRequiresAuth.Entity.Remote.Name,
 			Credentials: git.Credentials{
 				User:     creduser,
@@ -104,14 +104,12 @@ func (gui *Gui) submitAuthenticationView(g *gocui.Gui, v *gocui.View) error {
 			},
 		}
 	}
-	jobRequiresAuth.Entity.State = git.Queued
+	jobRequiresAuth.Entity.SetState(git.Queued)
 	// add this job to the last of the queue
 	err = gui.State.Queue.AddJob(jobRequiresAuth)
 	if err != nil {
 		return err
 	}
-	// refresh views with the updates
-	gui.refreshMain(g)
 	gui.closeAuthenticationView(g, v)
 	v_return, err := g.View(authenticationReturnView)
 	gui.startQueue(g, v_return)
diff --git a/pkg/gui/commitview.go b/pkg/gui/commitview.go
index 94ef574..0f22091 100644
--- a/pkg/gui/commitview.go
+++ b/pkg/gui/commitview.go
@@ -174,12 +174,6 @@ func (gui *Gui) closeCommitMessageView(g *gocui.Gui, v *gocui.View) error {
 			return err
 		}
 	}
-	if err := gui.refreshMain(g); err != nil {
-		return err
-	}
-	if err := gui.refreshViews(g, entity); err != nil {
-		return err
-	}
 	if err := refreshAllStatusView(g, entity, true); err != nil {
 		return err
 	}
diff --git a/pkg/gui/gui.go b/pkg/gui/gui.go
index 1fb94ad..2e1f2b2 100644
--- a/pkg/gui/gui.go
+++ b/pkg/gui/gui.go
@@ -2,6 +2,7 @@ package gui
 
 import (
 	"fmt"
+	"sync"
 
 	"github.com/isacikgoz/gitbatch/pkg/git"
 	"github.com/jroimartin/gocui"
@@ -14,6 +15,7 @@ type Gui struct {
 	g           *gocui.Gui
 	KeyBindings []*KeyBinding
 	State       guiState
+	mutex       *sync.Mutex
 }
 
 // guiState struct holds the repositories, directiories, mode and queue of the
@@ -81,6 +83,7 @@ func NewGui(mode string, directoies []string) (*Gui, error) {
 	}
 	gui := &Gui{
 		State: initialState,
+		mutex: &sync.Mutex{},
 	}
 	for _, m := range modes {
 		if string(m.ModeID) == mode {
@@ -121,6 +124,10 @@ func (gui *Gui) Run() error {
 			return
 		}
 		g_ui.State.Repositories = rs
+		// add gui's repositoryUpdated func as an observer to repositories
+		for _, repo := range rs {
+			repo.On(git.RepositoryUpdated, gui.repositoryUpdated)
+		}
 		gui.fillMain(g)
 	}(gui)
 
diff --git a/pkg/gui/mainview.go b/pkg/gui/mainview.go
index 389d66d..6bd55d9 100644
--- a/pkg/gui/mainview.go
+++ b/pkg/gui/mainview.go
@@ -16,9 +16,7 @@ func (gui *Gui) fillMain(g *gocui.Gui) error {
 		if err != nil {
 			return err
 		}
-		for _, r := range gui.State.Repositories {
-			fmt.Fprintln(v, gui.displayString(r))
-		}
+		// if there is still a loading screen we better get rid of it
 		err = g.DeleteView(loadingViewFeature.Name)
 		if err != nil {
 			return err
@@ -26,19 +24,22 @@ func (gui *Gui) fillMain(g *gocui.Gui) error {
 		if _, err = gui.setCurrentViewOnTop(g, mainViewFeature.Name); err != nil {
 			return err
 		}
+		// Sort by name is default behavior as expected, so it handles redrwaing
+		// the main view
 		if err = gui.sortByName(g, v); err != nil {
 			return err
 		}
-		entity := gui.getSelectedRepository()
-		gui.refreshViews(g, entity)
 		return nil
 	})
 	return nil
 }
 
 // refresh the main view and re-render the repository representations
-func (gui *Gui) refreshMain(g *gocui.Gui) error {
-	mainView, err := g.View(mainViewFeature.Name)
+func (gui *Gui) refreshMain() error {
+	gui.mutex.Lock()
+	defer gui.mutex.Unlock()
+
+	mainView, err := gui.g.View(mainViewFeature.Name)
 	if err != nil {
 		return err
 	}
@@ -46,6 +47,16 @@ func (gui *Gui) refreshMain(g *gocui.Gui) error {
 	for _, r := range gui.State.Repositories {
 		fmt.Fprintln(mainView, gui.displayString(r))
 	}
+	// while refreshing, refresh sideViews for selected entity, something may
+	// be changed?
+	return gui.refreshSideViews(gui.getSelectedRepository())
+}
+
+// listens the event -> "repository.updated"
+func (gui *Gui) repositoryUpdated(event *git.RepositoryEvent) error {
+	gui.g.Update(func(g *gocui.Gui) error {
+		return gui.refreshMain()
+	})
 	return nil
 }
 
@@ -62,18 +73,12 @@ func (gui *Gui) cursorDown(g *gocui.Gui, v *gocui.View) error {
 			return nil
 		}
 		if err := v.SetCursor(cx, cy+1); err != nil {
-
 			if err := v.SetOrigin(ox, oy+1); err != nil {
 				return err
 			}
 		}
-		entity := gui.getSelectedRepository()
-		if err := gui.refreshMain(g); err != nil {
-			return err
-		}
-		gui.refreshViews(g, entity)
 	}
-	return nil
+	return gui.refreshMain()
 }
 
 // moves the cursor upwards for the main view
@@ -86,13 +91,8 @@ func (gui *Gui) cursorUp(g *gocui.Gui, v *gocui.View) error {
 				return err
 			}
 		}
-		entity := gui.getSelectedRepository()
-		if err := gui.refreshMain(g); err != nil {
-			return err
-		}
-		gui.refreshViews(g, entity)
 	}
-	return nil
+	return gui.refreshMain()
 }
 
 // returns the entity at cursors position by taking its position in the gui's
@@ -129,7 +129,7 @@ func (gui *Gui) addToQueue(entity *git.RepoEntity) error {
 	if err != nil {
 		return err
 	}
-	entity.State = git.Queued
+	entity.SetState(git.Queued)
 	return nil
 }
 
@@ -139,7 +139,7 @@ func (gui *Gui) removeFromQueue(entity *git.RepoEntity) error {
 	if err != nil {
 		return err
 	}
-	entity.State = git.Available
+	entity.SetState(git.Available)
 	return nil
 }
 
@@ -148,18 +148,17 @@ func (gui *Gui) removeFromQueue(entity *git.RepoEntity) error {
 func (gui *Gui) markRepository(g *gocui.Gui, v *gocui.View) error {
 	r := gui.getSelectedRepository()
 	// maybe, failed entities may be added to queue again
-	if r.State == git.Available || r.State == git.Success || r.State == git.Paused {
+	if r.State() == git.Available || r.State() == git.Success || r.State() == git.Paused {
 		if err := gui.addToQueue(r); err != nil {
 			return err
 		}
-	} else if r.State == git.Queued {
+	} else if r.State() == git.Queued {
 		if err := gui.removeFromQueue(r); err != nil {
 			return err
 		}
 	} else {
 		return nil
 	}
-	gui.refreshMain(g)
 	return nil
 }
 
@@ -167,7 +166,7 @@ func (gui *Gui) markRepository(g *gocui.Gui, v *gocui.View) error {
 // current state into account before adding it
 func (gui *Gui) markAllRepositories(g *gocui.Gui, v *gocui.View) error {
 	for _, r := range gui.State.Repositories {
-		if r.State == git.Available || r.State == git.Success {
+		if r.State() == git.Available || r.State() == git.Success {
 			if err := gui.addToQueue(r); err != nil {
 				return err
 			}
@@ -175,7 +174,6 @@ func (gui *Gui) markAllRepositories(g *gocui.Gui, v *gocui.View) error {
 			continue
 		}
 	}
-	gui.refreshMain(g)
 	return nil
 }
 
@@ -183,7 +181,7 @@ func (gui *Gui) markAllRepositories(g *gocui.Gui, v *gocui.View) error {
 // current state into account before removing it
 func (gui *Gui) unmarkAllRepositories(g *gocui.Gui, v *gocui.View) error {
 	for _, r := range gui.State.Repositories {
-		if r.State == git.Queued {
+		if r.State() == git.Queued {
 			if err := gui.removeFromQueue(r); err != nil {
 				return err
 			}
@@ -191,14 +189,13 @@ func (gui *Gui) unmarkAllRepositories(g *gocui.Gui, v *gocui.View) error {
 			continue
 		}
 	}
-	gui.refreshMain(g)
 	return nil
 }
 
 // sortByName sorts the repositories by A to Z order
 func (gui *Gui) sortByName(g *gocui.Gui, v *gocui.View) error {
 	sort.Sort(git.Alphabetical(gui.State.Repositories))
-	gui.refreshAfterSort(g)
+	gui.refreshMain()
 	return nil
 }
 
@@ -206,14 +203,6 @@ func (gui *Gui) sortByName(g *gocui.Gui, v *gocui.View) error {
 // the top element will be the last modified
 func (gui *Gui) sortByMod(g *gocui.Gui, v *gocui.View) error {
 	sort.Sort(git.LastModified(gui.State.Repositories))
-	gui.refreshAfterSort(g)
-	return nil
-}
-
-// utility function that refreshes main and side views after that
-func (gui *Gui) refreshAfterSort(g *gocui.Gui) error {
-	gui.refreshMain(g)
-	entity := gui.getSelectedRepository()
-	gui.refreshViews(g, entity)
+	gui.refreshMain()
 	return nil
 }
diff --git a/pkg/gui/sideviews.go b/pkg/gui/sideviews.go
index 86aa3cb..b963391 100644
--- a/pkg/gui/sideviews.go
+++ b/pkg/gui/sideviews.go
@@ -12,10 +12,28 @@ var (
 	sideViews               = []viewFeature{remoteViewFeature, remoteBranchViewFeature, branchViewFeature, commitViewFeature}
 )
 
+// refreshes the side views of the application for given git.RepoEntity struct
+func (gui *Gui) refreshSideViews(entity *git.RepoEntity) error {
+	var err error
+	if err = gui.updateRemotes(entity); err != nil {
+		return err
+	}
+	if err = gui.updateBranch(entity); err != nil {
+		return err
+	}
+	if err = gui.updateRemoteBranches(entity); err != nil {
+		return err
+	}
+	if err = gui.updateCommits(entity); err != nil {
+		return err
+	}
+	return err
+}
+
 // updates the remotesview for given entity
-func (gui *Gui) updateRemotes(g *gocui.Gui, entity *git.RepoEntity) error {
+func (gui *Gui) updateRemotes(entity *git.RepoEntity) error {
 	var err error
-	out, err := g.View(remoteViewFeature.Name)
+	out, err := gui.g.View(remoteViewFeature.Name)
 	if err != nil {
 		return err
 	}
@@ -43,9 +61,9 @@ func (gui *Gui) updateRemotes(g *gocui.Gui, entity *git.RepoEntity) error {
 }
 
 // updates the remotebranchview for given entity
-func (gui *Gui) updateRemoteBranches(g *gocui.Gui, entity *git.RepoEntity) error {
+func (gui *Gui) updateRemoteBranches(entity *git.RepoEntity) error {
 	var err error
-	out, err := g.View(remoteBranchViewFeature.Name)
+	out, err := gui.g.View(remoteBranchViewFeature.Name)
 	if err != nil {
 		return err
 	}
@@ -73,9 +91,9 @@ func (gui *Gui) updateRemoteBranches(g *gocui.Gui, entity *git.RepoEntity) error
 }
 
 // updates the branchview for given entity
-func (gui *Gui) updateBranch(g *gocui.Gui, entity *git.RepoEntity) error {
+func (gui *Gui) updateBranch(entity *git.RepoEntity) error {
 	var err error
-	out, err := g.View(branchViewFeature.Name)
+	out, err := gui.g.View(branchViewFeature.Name)
 	if err != nil {
 		return err
 	}
@@ -96,9 +114,9 @@ func (gui *Gui) updateBranch(g *gocui.Gui, entity *git.RepoEntity) error {
 }
 
 // updates the commitsview for given entity
-func (gui *Gui) updateCommits(g *gocui.Gui, entity *git.RepoEntity) error {
+func (gui *Gui) updateCommits(entity *git.RepoEntity) error {
 	var err error
-	out, err := g.View(commitViewFeature.Name)
+	out, err := gui.g.View(commitViewFeature.Name)
 	if err != nil {
 		return err
 	}
@@ -136,12 +154,12 @@ func (gui *Gui) sideViewsNextItem(g *gocui.Gui, v *gocui.View) error {
 		if err = entity.Remote.NextRemoteBranch(); err != nil {
 			return err
 		}
-		err = gui.updateRemoteBranches(g, entity)
+		err = gui.updateRemoteBranches(entity)
 	case remoteViewFeature.Name:
 		if err = entity.NextRemote(); err != nil {
 			return err
 		}
-		err = gui.remoteChangeFollowUp(g, entity)
+		err = gui.remoteChangeFollowUp(entity)
 	case branchViewFeature.Name:
 		if err = entity.Checkout(entity.NextBranch()); err != nil {
 			err = gui.openErrorView(g, err.Error(),
@@ -149,12 +167,12 @@ func (gui *Gui) sideViewsNextItem(g *gocui.Gui, v *gocui.View) error {
 				branchViewFeature.Name)
 			return err
 		}
-		err = gui.checkoutFollowUp(g, entity)
+		err = gui.checkoutFollowUp(entity)
 	case commitViewFeature.Name:
 		if err = entity.NextCommit(); err != nil {
 			return err
 		}
-		err = gui.updateCommits(g, entity)
+		err = gui.updateCommits(entity)
 	}
 	return err
 }
@@ -167,12 +185,12 @@ func (gui *Gui) sideViewsPreviousItem(g *gocui.Gui, v *gocui.View) error {
 		if err = entity.Remote.PreviousRemoteBranch(); err != nil {
 			return err
 		}
-		err = gui.updateRemoteBranches(g, entity)
+		err = gui.updateRemoteBranches(entity)
 	case remoteViewFeature.Name:
 		if err = entity.PreviousRemote(); err != nil {
 			return err
 		}
-		err = gui.remoteChangeFollowUp(g, entity)
+		err = gui.remoteChangeFollowUp(entity)
 	case branchViewFeature.Name:
 		if err = entity.Checkout(entity.PreviousBranch()); err != nil {
 			err = gui.openErrorView(g, err.Error(),
@@ -180,12 +198,12 @@ func (gui *Gui) sideViewsPreviousItem(g *gocui.Gui, v *gocui.View) error {
 				branchViewFeature.Name)
 			return err
 		}
-		err = gui.checkoutFollowUp(g, entity)
+		err = gui.checkoutFollowUp(entity)
 	case commitViewFeature.Name:
 		if err = entity.PreviousCommit(); err != nil {
 			return err
 		}
-		err = gui.updateCommits(g, entity)
+		err = gui.updateCommits(entity)
 	}
 	return err
 }
@@ -208,7 +226,7 @@ func (gui *Gui) syncRemoteBranch(g *gocui.Gui, v *gocui.View) error {
 	// some time need to fix, movement aint bad huh?
 	gui.sideViewsNextItem(g, vr)
 	gui.sideViewsPreviousItem(g, vr)
-	err = gui.updateRemoteBranches(g, entity)
+	err = gui.updateRemoteBranches(entity)
 	return err
 }
 
@@ -247,7 +265,6 @@ func (gui *Gui) confirmSetUpstreamToBranch(g *gocui.Gui, v *gocui.View) error {
 		return err
 	}
 	entity.Refresh()
-	gui.refreshMain(g)
 	return gui.closeConfirmationView(g, v)
 }
 
@@ -259,25 +276,24 @@ func (gui *Gui) closeConfirmationView(g *gocui.Gui, v *gocui.View) error {
 }
 
 // after checkout a remote some refreshments needed
-func (gui *Gui) remoteChangeFollowUp(g *gocui.Gui, entity *git.RepoEntity) (err error) {
-	if err = gui.updateRemotes(g, entity); err != nil {
+func (gui *Gui) remoteChangeFollowUp(entity *git.RepoEntity) (err error) {
+	if err = gui.updateRemotes(entity); err != nil {
 		return err
 	}
-	err = gui.updateRemoteBranches(g, entity)
+	err = gui.updateRemoteBranches(entity)
 	return err
 }
 
 // after checkout a branch some refreshments needed
-func (gui *Gui) checkoutFollowUp(g *gocui.Gui, entity *git.RepoEntity) (err error) {
-	if err = gui.updateBranch(g, entity); err != nil {
+func (gui *Gui) checkoutFollowUp(entity *git.RepoEntity) (err error) {
+	if err = gui.updateBranch(entity); err != nil {
 		return err
 	}
-	if err = gui.updateCommits(g, entity); err != nil {
+	if err = gui.updateCommits(entity); err != nil {
 		return err
 	}
-	if err = gui.updateRemoteBranches(g, entity); err != nil {
+	if err = gui.updateRemoteBranches(entity); err != nil {
 		return err
 	}
-	err = gui.refreshMain(g)
 	return err
 }
diff --git a/pkg/gui/stashview.go b/pkg/gui/stashview.go
index 24b4f3c..6011df9 100644
--- a/pkg/gui/stashview.go
+++ b/pkg/gui/stashview.go
@@ -55,9 +55,9 @@ func (gui *Gui) popStash(g *gocui.Gui, v *gocui.View) error {
 			return err
 		}
 	}
-	if err := entity.Refresh(); err != nil {
-		return err
-	}
+	// since the pop is a func of stashed item, we need to refresh entity here
+	entity.Refresh()
+
 	err = refreshAllStatusView(g, entity, true)
 	return err
 }
diff --git a/pkg/gui/statusview.go b/pkg/gui/statusview.go
index 82df459..798b760 100644
--- a/pkg/gui/statusview.go
+++ b/pkg/gui/statusview.go
@@ -121,13 +121,7 @@ func (gui *Gui) closeStatusView(g *gocui.Gui, v *gocui.View) error {
 	}
 	stagedFiles = make([]*git.File, 0)
 	unstagedFiles = make([]*git.File, 0)
-	entity := gui.getSelectedRepository()
-	if err := gui.refreshMain(g); err != nil {
-		return err
-	}
-	if err := gui.refreshViews(g, entity); err != nil {
-		return err
-	}
+
 	return gui.closeViewCleanup(mainViewFeature.Name)
 }
 
diff --git a/pkg/gui/util-common.go b/pkg/gui/util-common.go
index f203bbf..3f6be1a 100644
--- a/pkg/gui/util-common.go
+++ b/pkg/gui/util-common.go
@@ -1,30 +1,11 @@
 package gui
 
 import (
-	"github.com/isacikgoz/gitbatch/pkg/git"
 	"github.com/isacikgoz/gitbatch/pkg/helpers"
 	"github.com/jroimartin/gocui"
 	log "github.com/sirupsen/logrus"
 )
 
-// refreshes the side views of the application for given git.RepoEntity struct
-func (gui *Gui) refreshViews(g *gocui.Gui, entity *git.RepoEntity) error {
-	var err error
-	if err = gui.updateRemotes(g, entity); err != nil {
-		return err
-	}
-	if err = gui.updateBranch(g, entity); err != nil {
-		return err
-	}
-	if err = gui.updateRemoteBranches(g, entity); err != nil {
-		return err
-	}
-	if err = gui.updateCommits(g, entity); err != nil {
-		return err
-	}
-	return err
-}
-
 // focus to next view
 func (gui *Gui) nextViewOfGroup(g *gocui.Gui, v *gocui.View, group []viewFeature) error {
 	var focusedViewName string
@@ -77,22 +58,6 @@ func (gui *Gui) previousViewOfGroup(g *gocui.Gui, v *gocui.View, group []viewFea
 	return nil
 }
 
-// siwtch the app mode
-func (gui *Gui) switchMode(g *gocui.Gui, v *gocui.View) error {
-	for i, mode := range modes {
-		if mode == gui.State.Mode {
-			if i == len(modes)-1 {
-				gui.State.Mode = modes[0]
-				break
-			}
-			gui.State.Mode = modes[i+1]
-			break
-		}
-	}
-	gui.updateKeyBindingsView(g, mainViewFeature.Name)
-	return nil
-}
-
 // siwtch the app's mode to fetch
 func (gui *Gui) switchToFetchMode(g *gocui.Gui, v *gocui.View) error {
 	gui.State.Mode = fetchMode
diff --git a/pkg/gui/util-queuehandler.go b/pkg/gui/util-queuehandler.go
index a814c47..e303825 100644
--- a/pkg/gui/util-queuehandler.go
+++ b/pkg/gui/util-queuehandler.go
@@ -12,17 +12,11 @@ func (gui *Gui) startQueue(g *gocui.Gui, v *gocui.View) error {
 	go func(gui_go *Gui, g_go *gocui.Gui) {
 		for {
 			job, finished, err := gui_go.State.Queue.StartNext()
-			// for each job execution we better refresh the main
-			// it would be nice if we can also refresh side views
-			g_go.Update(func(gu *gocui.Gui) error {
-				gui_go.refreshMain(gu)
-				return nil
-			})
 
 			if err != nil {
 				if err == git.ErrAuthenticationRequired {
 					// pause the job, so it will be indicated to being blocking
-					job.Entity.State = git.Paused
+					job.Entity.SetState(git.Paused)
 					err := gui_go.openAuthenticationView(g, gui_go.State.Queue, job, v.Name())
 					if err != nil {
 						log.Warn(err.Error())
@@ -36,23 +30,7 @@ func (gui *Gui) startQueue(g *gocui.Gui, v *gocui.View) error {
 			if finished {
 				return
 			}
-			selectedEntity := gui_go.getSelectedRepository()
-			if job.Entity == selectedEntity {
-				gui_go.refreshViews(g, job.Entity)
-			}
 		}
 	}(gui, g)
 	return nil
 }
-
-// flashes the keybinding view's backgroun with green color to indicate that
-// the queue is started
-func indicateQueueStarted(g *gocui.Gui) error {
-	v, err := g.View(keybindingsViewFeature.Name)
-	if err != nil {
-		return err
-	}
-	v.BgColor = gocui.ColorGreen
-	v.FgColor = gocui.ColorBlack
-	return nil
-}
diff --git a/pkg/gui/util-textstyle.go b/pkg/gui/util-textstyle.go
index 7c36263..d303d9c 100644
--- a/pkg/gui/util-textstyle.go
+++ b/pkg/gui/util-textstyle.go
@@ -86,7 +86,7 @@ func (gui *Gui) displayString(entity *git.RepoEntity) string {
 	}
 
 	// rendering the satus according to repository's state
-	if entity.State == git.Queued {
+	if entity.State() == git.Queued {
 		if inQueue, ty := gui.State.Queue.IsInTheQueue(entity); inQueue {
 			switch mode := ty; mode {
 			case git.FetchJob:
@@ -100,14 +100,14 @@ func (gui *Gui) displayString(entity *git.RepoEntity) string {
 			}
 		}
 		return prefix + repoName + ws + suffix
-	} else if entity.State == git.Working {
+	} else if entity.State() == git.Working {
 		// TODO: maybe the type of the job can be written while its working?
 		return prefix + repoName + ws + green.Sprint(workingSymbol)
-	} else if entity.State == git.Success {
+	} else if entity.State() == git.Success {
 		return prefix + repoName + ws + green.Sprint(successSymbol)
-	} else if entity.State == git.Paused {
+	} else if entity.State() == git.Paused {
 		return prefix + repoName + ws + yellow.Sprint(pauseSymbol)
-	} else if entity.State == git.Fail {
+	} else if entity.State() == git.Fail {
 		return prefix + repoName + ws + red.Sprint(failSymbol)
 	} else {
 		return prefix + repoName