refactor on var name

11 files changed, 147 insertions, 147 deletions

diff --git a/gui/authenticationview.go b/gui/authenticationview.go
index 1b5c98f..97a214e 100644
--- a/gui/authenticationview.go
+++ b/gui/authenticationview.go
@@ -41,8 +41,8 @@ func (gui *Gui) openAuthenticationView(g *gocui.Gui, jobQueue *job.JobQueue, job
 		return err
 	}
 	jobRequiresAuth = job
-	if job.Entity.State() != git.Fail {
-		if err := jobQueue.RemoveFromQueue(job.Entity); err != nil {
+	if job.Repository.State() != git.Fail {
+		if err := jobQueue.RemoveFromQueue(job.Repository); err != nil {
 			log.Fatal(err.Error())
 			return err
 		}
@@ -53,7 +53,7 @@ func (gui *Gui) openAuthenticationView(g *gocui.Gui, jobQueue *job.JobQueue, job
 		if err != gocui.ErrUnknownView {
 			return err
 		}
-		fmt.Fprintln(v, keySymbol+selectionIndicator+red.Sprint(jobRequiresAuth.Entity.Remote.URL[0]))
+		fmt.Fprintln(v, keySymbol+selectionIndicator+red.Sprint(jobRequiresAuth.Repository.Remote.URL[0]))
 	}
 	g.Cursor = true
 	if err := gui.openUserView(g); err != nil {
@@ -104,7 +104,7 @@ func (gui *Gui) submitAuthenticationView(g *gocui.Gui, v *gocui.View) error {
 	switch mode := jobRequiresAuth.JobType; mode {
 	case job.FetchJob:
 		jobRequiresAuth.Options = command.FetchOptions{
-			RemoteName: jobRequiresAuth.Entity.Remote.Name,
+			RemoteName: jobRequiresAuth.Repository.Remote.Name,
 			Credentials: git.Credentials{
 				User:     creduser,
 				Password: credpswd,
@@ -113,14 +113,14 @@ func (gui *Gui) submitAuthenticationView(g *gocui.Gui, v *gocui.View) error {
 	case job.PullJob:
 		// we handle pull as fetch&merge so same rule applies
 		jobRequiresAuth.Options = command.PullOptions{
-			RemoteName: jobRequiresAuth.Entity.Remote.Name,
+			RemoteName: jobRequiresAuth.Repository.Remote.Name,
 			Credentials: git.Credentials{
 				User:     creduser,
 				Password: credpswd,
 			},
 		}
 	}
-	jobRequiresAuth.Entity.SetState(git.Queued)
+	jobRequiresAuth.Repository.SetState(git.Queued)
 
 	// add this job to the last of the queue
 	if err := gui.State.Queue.AddJob(jobRequiresAuth); err != nil {
diff --git a/gui/commitview.go b/gui/commitview.go
index ad8adee..7acc5ca 100644
--- a/gui/commitview.go
+++ b/gui/commitview.go
@@ -57,7 +57,7 @@ func (gui *Gui) openCommitMessageView(g *gocui.Gui, v *gocui.View) error {
 
 // open an error view to inform user with a message and a useful note
 func (gui *Gui) openCommitUserNameView(g *gocui.Gui) error {
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	maxX, maxY := g.Size()
 	// first, create the label for user
 	vlabel, err := g.SetView(commitUserNameLabelFeature.Name, maxX/2-30, maxY/2, maxX/2-19, maxY/2+2)
@@ -74,7 +74,7 @@ func (gui *Gui) openCommitUserNameView(g *gocui.Gui) error {
 		if err != gocui.ErrUnknownView {
 			return err
 		}
-		name, err := command.Config(e, command.ConfigOptions{
+		name, err := command.Config(r, command.ConfigOptions{
 			Section: "user",
 			Option:  "name",
 		})
@@ -90,7 +90,7 @@ func (gui *Gui) openCommitUserNameView(g *gocui.Gui) error {
 
 // open an error view to inform user with a message and a useful note
 func (gui *Gui) openCommitUserEmailView(g *gocui.Gui) error {
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	maxX, maxY := g.Size()
 	// first, create the label for password
 	vlabel, err := g.SetView(commitUserEmailLabelViewFeature.Name, maxX/2-30, maxY/2+1, maxX/2-19, maxY/2+3)
@@ -107,7 +107,7 @@ func (gui *Gui) openCommitUserEmailView(g *gocui.Gui) error {
 		if err != gocui.ErrUnknownView {
 			return err
 		}
-		email, err := command.Config(e, command.ConfigOptions{
+		email, err := command.Config(r, command.ConfigOptions{
 			Section: "user",
 			Option:  "email",
 		})
@@ -123,7 +123,7 @@ func (gui *Gui) openCommitUserEmailView(g *gocui.Gui) error {
 
 // close the opened commite mesage view
 func (gui *Gui) submitCommitMessageView(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 
 	// in order to read buffer of the views, first we need to find'em
 	vMsg, err := g.View(commitMessageViewFeature.Name)
@@ -151,7 +151,7 @@ func (gui *Gui) submitCommitMessageView(g *gocui.Gui, v *gocui.View) error {
 		return errors.New("User email needs to be provided")
 	}
 
-	err = command.CommitCommand(e, command.CommitOptions{
+	err = command.CommitCommand(r, command.CommitOptions{
 		CommitMsg: msg,
 		User:      name,
 		Email:     email,
@@ -170,7 +170,7 @@ func (gui *Gui) nextCommitView(g *gocui.Gui, v *gocui.View) error {
 
 // close the opened commite mesage view
 func (gui *Gui) closeCommitMessageView(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	g.Cursor = false
 	for _, view := range commitViews {
 		if err := g.DeleteView(view.Name); err != nil {
@@ -182,7 +182,7 @@ func (gui *Gui) closeCommitMessageView(g *gocui.Gui, v *gocui.View) error {
 			return err
 		}
 	}
-	if err := refreshAllStatusView(g, e, true); err != nil {
+	if err := refreshAllStatusView(g, r, true); err != nil {
 		return err
 	}
 	return gui.closeViewCleanup(commitMesageReturnView)
diff --git a/gui/diffview.go b/gui/diffview.go
index e78dcaf..3bf9b05 100644
--- a/gui/diffview.go
+++ b/gui/diffview.go
@@ -34,11 +34,11 @@ func (gui *Gui) prepareDiffView(g *gocui.Gui, v *gocui.View, display []string) (
 // open diff view for the selcted commit
 // called from commitview, so initial view is commitview
 func (gui *Gui) openCommitDiffView(g *gocui.Gui, v *gocui.View) (err error) {
-	e := gui.getSelectedRepository()
-	commit := e.Commit
+	r := gui.getSelectedRepository()
+	commit := r.Commit
 	commitDetail := []string{("Hash: " + cyan.Sprint(commit.Hash) + "\n" + "Author: " + commit.Author +
 		"\n" + commit.Time + "\n" + "\n" + "\t\t" + commit.Message + "\n")}
-	diff, err := command.Diff(e, e.Commit.Hash)
+	diff, err := command.Diff(r, r.Commit.Hash)
 	if err != nil {
 		return err
 	}
@@ -93,13 +93,13 @@ func (gui *Gui) openFileDiffView(g *gocui.Gui, v *gocui.View) (err error) {
 
 // called from stashview, so initial view is stashview
 func (gui *Gui) showStash(g *gocui.Gui, v *gocui.View) (err error) {
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	_, oy := v.Origin()
 	_, cy := v.Cursor()
-	if len(e.Stasheds) <= 0 {
+	if len(r.Stasheds) <= 0 {
 		return nil
 	}
-	stashedItem := e.Stasheds[oy+cy]
+	stashedItem := r.Stasheds[oy+cy]
 	output, err := stashedItem.Show()
 	if err != nil {
 		if err = gui.openErrorView(g, output,
diff --git a/gui/gui.go b/gui/gui.go
index e593b5f..84bdb51 100644
--- a/gui/gui.go
+++ b/gui/gui.go
@@ -22,7 +22,7 @@ type Gui struct {
 // guiState struct holds the repositories, directiories, mode and queue of the
 // gui object. These values are not static
 type guiState struct {
-	Repositories  []*git.RepoEntity
+	Repositories  []*git.Repository
 	Directories   []string
 	Mode          mode
 	Queue         *job.JobQueue
@@ -131,9 +131,9 @@ func (gui *Gui) Run() error {
 	return nil
 }
 
-func (gui *Gui) addRepository(e *git.RepoEntity) {
-	gui.State.Repositories = append(gui.State.Repositories, e)
-	e.On(git.RepositoryUpdated, gui.repositoryUpdated)
+func (gui *Gui) addRepository(r *git.Repository) {
+	gui.State.Repositories = append(gui.State.Repositories, r)
+	r.On(git.RepositoryUpdated, gui.repositoryUpdated)
 	gui.repositoryUpdated(nil)
 }
 
diff --git a/gui/mainview.go b/gui/mainview.go
index 288ca8f..f12a26c 100644
--- a/gui/mainview.go
+++ b/gui/mainview.go
@@ -162,7 +162,7 @@ func (gui *Gui) pageUp(g *gocui.Gui, v *gocui.View) error {
 // slice of repositories. Since it is not a %100 percent safe methodology it may
 // rrequire a better implementation or the slice's order must be synchronized
 // with the views lines
-func (gui *Gui) getSelectedRepository() *git.RepoEntity {
+func (gui *Gui) getSelectedRepository() *git.Repository {
 	if len(gui.State.Repositories) == 0 {
 		return nil
 	}
@@ -173,7 +173,7 @@ func (gui *Gui) getSelectedRepository() *git.RepoEntity {
 }
 
 // adds given entity to job queue
-func (gui *Gui) addToQueue(entity *git.RepoEntity) error {
+func (gui *Gui) addToQueue(r *git.Repository) error {
 	var jt job.JobType
 	switch mode := gui.State.Mode.ModeID; mode {
 	case FetchMode:
@@ -186,23 +186,23 @@ func (gui *Gui) addToQueue(entity *git.RepoEntity) error {
 		return nil
 	}
 	err := gui.State.Queue.AddJob(&job.Job{
-		JobType: jt,
-		Entity:  entity,
+		JobType:    jt,
+		Repository: r,
 	})
 	if err != nil {
 		return err
 	}
-	entity.SetState(git.Queued)
+	r.SetState(git.Queued)
 	return nil
 }
 
 // removes given entity from job queue
-func (gui *Gui) removeFromQueue(entity *git.RepoEntity) error {
-	err := gui.State.Queue.RemoveFromQueue(entity)
+func (gui *Gui) removeFromQueue(r *git.Repository) error {
+	err := gui.State.Queue.RemoveFromQueue(r)
 	if err != nil {
 		return err
 	}
-	entity.SetState(git.Available)
+	r.SetState(git.Available)
 	return nil
 }
 
@@ -214,7 +214,7 @@ func (gui *Gui) startQueue(g *gocui.Gui, v *gocui.View) error {
 		gui_go.State.Queue = job.CreateJobQueue()
 		for j, err := range fails {
 			if err == gerr.ErrAuthenticationRequired {
-				j.Entity.SetState(git.Paused)
+				j.Repository.SetState(git.Paused)
 				gui_go.State.FailoverQueue.AddJob(j)
 			}
 		}
@@ -224,14 +224,14 @@ func (gui *Gui) startQueue(g *gocui.Gui, v *gocui.View) error {
 
 func (gui *Gui) submitCredentials(g *gocui.Gui, v *gocui.View) error {
 	if is, j := gui.State.FailoverQueue.IsInTheQueue(gui.getSelectedRepository()); is {
-		if j.Entity.State() == git.Paused {
-			gui.State.FailoverQueue.RemoveFromQueue(j.Entity)
+		if j.Repository.State() == git.Paused {
+			gui.State.FailoverQueue.RemoveFromQueue(j.Repository)
 			err := gui.openAuthenticationView(g, gui.State.Queue, j, v.Name())
 			if err != nil {
 				log.Warn(err.Error())
 				return err
 			}
-			if isnt, _ := gui.State.Queue.IsInTheQueue(j.Entity); !isnt {
+			if isnt, _ := gui.State.Queue.IsInTheQueue(j.Repository); !isnt {
 				gui.State.FailoverQueue.AddJob(j)
 			}
 		}
diff --git a/gui/sideviews.go b/gui/sideviews.go
index 1139054..5a3adc7 100644
--- a/gui/sideviews.go
+++ b/gui/sideviews.go
@@ -13,29 +13,29 @@ var (
 	sideViews               = []viewFeature{remoteViewFeature, remoteBranchViewFeature, branchViewFeature, commitViewFeature}
 )
 
-// refreshes the side views of the application for given repository.RepoEntity struct
-func (gui *Gui) renderSideViews(e *git.RepoEntity) error {
-	if e == nil {
+// refreshes the side views of the application for given repository.Repository struct
+func (gui *Gui) renderSideViews(r *git.Repository) error {
+	if r == nil {
 		return nil
 	}
 
-	if err := gui.renderRemotes(e); err != nil {
+	if err := gui.renderRemotes(r); err != nil {
 		return err
 	}
-	if err := gui.renderBranch(e); err != nil {
+	if err := gui.renderBranch(r); err != nil {
 		return err
 	}
-	if err := gui.renderRemoteBranches(e); err != nil {
+	if err := gui.renderRemoteBranches(r); err != nil {
 		return err
 	}
-	if err := gui.renderCommits(e); err != nil {
+	if err := gui.renderCommits(r); err != nil {
 		return err
 	}
 	return nil
 }
 
 // updates the remotesview for given entity
-func (gui *Gui) renderRemotes(e *git.RepoEntity) error {
+func (gui *Gui) renderRemotes(r *git.Repository) error {
 	var err error
 	out, err := gui.g.View(remoteViewFeature.Name)
 	if err != nil {
@@ -43,16 +43,16 @@ func (gui *Gui) renderRemotes(e *git.RepoEntity) error {
 	}
 	out.Clear()
 	currentindex := 0
-	totalRemotes := len(e.Remotes)
+	totalRemotes := len(r.Remotes)
 	if totalRemotes > 0 {
-		for i, r := range e.Remotes {
-			_, shortURL := trimRemoteURL(r.URL[0])
-			if r.Name == e.Remote.Name {
+		for i, rm := range r.Remotes {
+			_, shortURL := trimRemoteURL(rm.URL[0])
+			if rm.Name == r.Remote.Name {
 				currentindex = i
-				fmt.Fprintln(out, selectionIndicator+r.Name+": "+shortURL)
+				fmt.Fprintln(out, selectionIndicator+rm.Name+": "+shortURL)
 				continue
 			}
-			fmt.Fprintln(out, tab+r.Name+": "+shortURL)
+			fmt.Fprintln(out, tab+rm.Name+": "+shortURL)
 		}
 		if err = gui.smartAnchorRelativeToLine(out, currentindex, totalRemotes); err != nil {
 			return err
@@ -62,7 +62,7 @@ func (gui *Gui) renderRemotes(e *git.RepoEntity) error {
 }
 
 // updates the remotebranchview for given entity
-func (gui *Gui) renderRemoteBranches(e *git.RepoEntity) error {
+func (gui *Gui) renderRemoteBranches(r *git.Repository) error {
 	var err error
 	out, err := gui.g.View(remoteBranchViewFeature.Name)
 	if err != nil {
@@ -70,15 +70,15 @@ func (gui *Gui) renderRemoteBranches(e *git.RepoEntity) error {
 	}
 	out.Clear()
 	currentindex := 0
-	trb := len(e.Remote.Branches)
+	trb := len(r.Remote.Branches)
 	if trb > 0 {
-		for i, r := range e.Remote.Branches {
-			if r.Name == e.Remote.Branch.Name {
+		for i, rm := range r.Remote.Branches {
+			if rm.Name == r.Remote.Branch.Name {
 				currentindex = i
-				fmt.Fprintln(out, selectionIndicator+r.Name)
+				fmt.Fprintln(out, selectionIndicator+rm.Name)
 				continue
 			}
-			fmt.Fprintln(out, tab+r.Name)
+			fmt.Fprintln(out, tab+rm.Name)
 		}
 		if err = gui.smartAnchorRelativeToLine(out, currentindex, trb); err != nil {
 			return err
@@ -88,7 +88,7 @@ func (gui *Gui) renderRemoteBranches(e *git.RepoEntity) error {
 }
 
 // updates the branchview for given entity
-func (gui *Gui) renderBranch(e *git.RepoEntity) error {
+func (gui *Gui) renderBranch(r *git.Repository) error {
 	var err error
 	out, err := gui.g.View(branchViewFeature.Name)
 	if err != nil {
@@ -96,9 +96,9 @@ func (gui *Gui) renderBranch(e *git.RepoEntity) error {
 	}
 	out.Clear()
 	currentindex := 0
-	totalbranches := len(e.Branches)
-	for i, b := range e.Branches {
-		if b.Name == e.Branch.Name {
+	totalbranches := len(r.Branches)
+	for i, b := range r.Branches {
+		if b.Name == r.Branch.Name {
 			currentindex = i
 			fmt.Fprintln(out, selectionIndicator+b.Name)
 			continue
@@ -110,7 +110,7 @@ func (gui *Gui) renderBranch(e *git.RepoEntity) error {
 }
 
 // updates the commitsview for given entity
-func (gui *Gui) renderCommits(e *git.RepoEntity) error {
+func (gui *Gui) renderCommits(r *git.Repository) error {
 	var err error
 	out, err := gui.g.View(commitViewFeature.Name)
 	if err != nil {
@@ -118,9 +118,9 @@ func (gui *Gui) renderCommits(e *git.RepoEntity) error {
 	}
 	out.Clear()
 	currentindex := 0
-	totalcommits := len(e.Commits)
-	for i, c := range e.Commits {
-		if c.Hash == e.Commit.Hash {
+	totalcommits := len(r.Commits)
+	for i, c := range r.Commits {
+		if c.Hash == r.Commit.Hash {
 			currentindex = i
 			fmt.Fprintln(out, selectionIndicator+commitLabel(c))
 			continue
@@ -133,22 +133,22 @@ func (gui *Gui) renderCommits(e *git.RepoEntity) error {
 // cursor down variant for sideviews
 func (gui *Gui) sideViewsNextItem(g *gocui.Gui, v *gocui.View) error {
 	var err error
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	switch viewName := v.Name(); viewName {
 	case remoteBranchViewFeature.Name:
-		return e.Remote.NextRemoteBranch(e)
+		return r.Remote.NextRemoteBranch(r)
 	case remoteViewFeature.Name:
-		return e.NextRemote()
+		return r.NextRemote()
 	case branchViewFeature.Name:
-		if err = e.Checkout(e.NextBranch()); err != nil {
+		if err = r.Checkout(r.NextBranch()); err != nil {
 			err = gui.openErrorView(g, err.Error(),
 				"You should manually resolve this issue",
 				branchViewFeature.Name)
 			return err
 		}
 	case commitViewFeature.Name:
-		e.NextCommit()
-		return gui.renderCommits(e)
+		r.NextCommit()
+		return gui.renderCommits(r)
 	}
 	return err
 }
@@ -156,31 +156,31 @@ func (gui *Gui) sideViewsNextItem(g *gocui.Gui, v *gocui.View) error {
 // cursor up variant for sideviews
 func (gui *Gui) sideViewsPreviousItem(g *gocui.Gui, v *gocui.View) error {
 	var err error
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	switch viewName := v.Name(); viewName {
 	case remoteBranchViewFeature.Name:
-		return e.Remote.PreviousRemoteBranch(e)
+		return r.Remote.PreviousRemoteBranch(r)
 	case remoteViewFeature.Name:
-		return e.PreviousRemote()
+		return r.PreviousRemote()
 	case branchViewFeature.Name:
-		if err = e.Checkout(e.PreviousBranch()); err != nil {
+		if err = r.Checkout(r.PreviousBranch()); err != nil {
 			err = gui.openErrorView(g, err.Error(),
 				"You should manually resolve this issue",
 				branchViewFeature.Name)
 			return err
 		}
 	case commitViewFeature.Name:
-		e.PreviousCommit()
-		return gui.renderCommits(e)
+		r.PreviousCommit()
+		return gui.renderCommits(r)
 	}
 	return err
 }
 
 // basically does fetch --prune
 func (gui *Gui) syncRemoteBranch(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
-	return command.Fetch(e, command.FetchOptions{
-		RemoteName: e.Remote.Name,
+	r := gui.getSelectedRepository()
+	return command.Fetch(r, command.FetchOptions{
+		RemoteName: r.Remote.Name,
 		Prune:      true,
 	})
 }
@@ -189,14 +189,14 @@ func (gui *Gui) syncRemoteBranch(g *gocui.Gui, v *gocui.View) error {
 func (gui *Gui) setUpstreamToBranch(g *gocui.Gui, v *gocui.View) error {
 	maxX, maxY := g.Size()
 
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	v, err := g.SetView(confirmationViewFeature.Name, maxX/2-30, maxY/2-2, maxX/2+30, maxY/2+2)
 	if err != nil {
 		if err != gocui.ErrUnknownView {
 			return err
 		}
-		fmt.Fprintln(v, "branch."+e.Branch.Name+"."+"remote"+"="+e.Remote.Name)
-		fmt.Fprintln(v, "branch."+e.Branch.Name+"."+"merge"+"="+e.Branch.Reference.Name().String())
+		fmt.Fprintln(v, "branch."+r.Branch.Name+"."+"remote"+"="+r.Remote.Name)
+		fmt.Fprintln(v, "branch."+r.Branch.Name+"."+"merge"+"="+r.Branch.Reference.Name().String())
 	}
 	return gui.focusToView(confirmationViewFeature.Name)
 }
@@ -204,22 +204,22 @@ func (gui *Gui) setUpstreamToBranch(g *gocui.Gui, v *gocui.View) error {
 // add config for upstream merge
 func (gui *Gui) confirmSetUpstreamToBranch(g *gocui.Gui, v *gocui.View) error {
 	var err error
-	e := gui.getSelectedRepository()
-	if err = command.AddConfig(e, command.ConfigOptions{
-		Section: "branch." + e.Branch.Name,
+	r := gui.getSelectedRepository()
+	if err = command.AddConfig(r, command.ConfigOptions{
+		Section: "branch." + r.Branch.Name,
 		Option:  "remote",
 		Site:    command.ConfigSiteLocal,
-	}, e.Remote.Name); err != nil {
+	}, r.Remote.Name); err != nil {
 		return err
 	}
-	if err = command.AddConfig(e, command.ConfigOptions{
-		Section: "branch." + e.Branch.Name,
+	if err = command.AddConfig(r, command.ConfigOptions{
+		Section: "branch." + r.Branch.Name,
 		Option:  "merge",
 		Site:    command.ConfigSiteLocal,
-	}, e.Branch.Reference.Name().String()); err != nil {
+	}, r.Branch.Reference.Name().String()); err != nil {
 		return err
 	}
-	e.Refresh()
+	r.Refresh()
 	return gui.closeConfirmationView(g, v)
 }
 
diff --git a/gui/stagedview.go b/gui/stagedview.go
index 5f68f5a..95b474a 100644
--- a/gui/stagedview.go
+++ b/gui/stagedview.go
@@ -25,32 +25,32 @@ func (gui *Gui) openStageView(g *gocui.Gui) error {
 }
 
 func (gui *Gui) resetChanges(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 
 	_, cy := v.Cursor()
 	_, oy := v.Origin()
 	if len(stagedFiles) <= 0 || len(stagedFiles) <= cy+oy {
 		return nil
 	}
-	if err := command.Reset(e, stagedFiles[cy+oy], command.ResetOptions{}); err != nil {
+	if err := command.Reset(r, stagedFiles[cy+oy], command.ResetOptions{}); err != nil {
 		return err
 	}
-	return refreshAllStatusView(g, e, true)
+	return refreshAllStatusView(g, r, true)
 }
 
 func (gui *Gui) resetAllChanges(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
-	ref, err := e.Repository.Head()
+	r := gui.getSelectedRepository()
+	ref, err := r.Repo.Head()
 	if err != nil {
 		return err
 	}
-	if err := command.ResetAll(e, command.ResetOptions{
+	if err := command.ResetAll(r, command.ResetOptions{
 		Hash:  ref.Hash().String(),
 		Rtype: command.ResetMixed,
 	}); err != nil {
 		return err
 	}
-	return refreshAllStatusView(g, e, true)
+	return refreshAllStatusView(g, r, true)
 }
 
 // refresh the main view and re-render the repository representations
diff --git a/gui/stashview.go b/gui/stashview.go
index 05f0a09..f1ecc48 100644
--- a/gui/stashview.go
+++ b/gui/stashview.go
@@ -18,15 +18,15 @@ func (gui *Gui) openStashView(g *gocui.Gui) error {
 		}
 		v.Title = stashViewFeature.Title
 	}
-	e := gui.getSelectedRepository()
-	err = refreshStashView(g, e)
+	r := gui.getSelectedRepository()
+	err = refreshStashView(g, r)
 	return err
 }
 
 //
 func (gui *Gui) stashChanges(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
-	output, err := e.Stash()
+	r := gui.getSelectedRepository()
+	output, err := r.Stash()
 	if err != nil {
 		if err = gui.openErrorView(g, output,
 			"You should manually resolve this issue",
@@ -34,19 +34,19 @@ func (gui *Gui) stashChanges(g *gocui.Gui, v *gocui.View) error {
 			return err
 		}
 	}
-	err = refreshAllStatusView(g, e, true)
+	err = refreshAllStatusView(g, r, true)
 	return err
 }
 
 //
 func (gui *Gui) popStash(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	_, oy := v.Origin()
 	_, cy := v.Cursor()
-	if len(e.Stasheds) <= 0 {
+	if len(r.Stasheds) <= 0 {
 		return nil
 	}
-	stashedItem := e.Stasheds[oy+cy]
+	stashedItem := r.Stasheds[oy+cy]
 	output, err := stashedItem.Pop()
 	if err != nil {
 		if err = gui.openErrorView(g, output,
@@ -56,15 +56,15 @@ func (gui *Gui) popStash(g *gocui.Gui, v *gocui.View) error {
 		}
 	}
 	// since the pop is a func of stashed item, we need to refresh entity here
-	if err := e.Refresh(); err != nil {
+	if err := r.Refresh(); err != nil {
 		return err
 	}
 
-	return refreshAllStatusView(g, e, true)
+	return refreshAllStatusView(g, r, true)
 }
 
 // refresh the main view and re-render the repository representations
-func refreshStashView(g *gocui.Gui, e *git.RepoEntity) error {
+func refreshStashView(g *gocui.Gui, r *git.Repository) error {
 	stashView, err := g.View(stashViewFeature.Name)
 	if err != nil {
 		return err
@@ -72,7 +72,7 @@ func refreshStashView(g *gocui.Gui, e *git.RepoEntity) error {
 	stashView.Clear()
 	_, cy := stashView.Cursor()
 	_, oy := stashView.Origin()
-	stashedItems := e.Stasheds
+	stashedItems := r.Stasheds
 	for i, stashedItem := range stashedItems {
 		var prefix string
 		if i == cy+oy {
diff --git a/gui/statusview.go b/gui/statusview.go
index 1648c4e..7b92e6a 100644
--- a/gui/statusview.go
+++ b/gui/statusview.go
@@ -64,8 +64,8 @@ func (gui *Gui) statusCursorDown(g *gocui.Gui, v *gocui.View) error {
 			return err
 		}
 	}
-	e := gui.getSelectedRepository()
-	return refreshStatusView(v.Name(), g, e, false)
+	r := gui.getSelectedRepository()
+	return refreshStatusView(v.Name(), g, r, false)
 }
 
 // moves the cursor upwards for the main view
@@ -81,20 +81,20 @@ func (gui *Gui) statusCursorUp(g *gocui.Gui, v *gocui.View) error {
 			return err
 		}
 	}
-	e := gui.getSelectedRepository()
-	return refreshStatusView(v.Name(), g, e, false)
+	r := gui.getSelectedRepository()
+	return refreshStatusView(v.Name(), g, r, false)
 }
 
 // header og the status layout
 func (gui *Gui) openStatusHeaderView(g *gocui.Gui) error {
 	maxX, _ := g.Size()
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 	v, err := g.SetView(statusHeaderViewFeature.Name, 6, 2, maxX-6, 4)
 	if err != nil {
 		if err != gocui.ErrUnknownView {
 			return err
 		}
-		fmt.Fprintln(v, e.AbsPath)
+		fmt.Fprintln(v, r.AbsPath)
 		// v.Frame = false
 		v.Wrap = true
 	}
@@ -118,8 +118,8 @@ func (gui *Gui) closeStatusView(g *gocui.Gui, v *gocui.View) error {
 }
 
 // generate file lists by git status command
-func populateFileLists(e *git.RepoEntity) error {
-	files, err := command.Status(e)
+func populateFileLists(r *git.Repository) error {
+	files, err := command.Status(r)
 	if err != nil {
 		return err
 	}
@@ -136,9 +136,9 @@ func populateFileLists(e *git.RepoEntity) error {
 	return err
 }
 
-func refreshStatusView(viewName string, g *gocui.Gui, e *git.RepoEntity, reload bool) error {
+func refreshStatusView(viewName string, g *gocui.Gui, r *git.Repository, reload bool) error {
 	if reload {
-		populateFileLists(e)
+		populateFileLists(r)
 	}
 	var err error
 	switch viewName {
@@ -147,14 +147,14 @@ func refreshStatusView(viewName string, g *gocui.Gui, e *git.RepoEntity, reload
 	case unstageViewFeature.Name:
 		err = refreshUnstagedView(g)
 	case stashViewFeature.Name:
-		err = refreshStashView(g, e)
+		err = refreshStashView(g, r)
 	}
 	return err
 }
 
-func refreshAllStatusView(g *gocui.Gui, e *git.RepoEntity, reload bool) error {
+func refreshAllStatusView(g *gocui.Gui, r *git.Repository, reload bool) error {
 	for _, v := range statusViews {
-		if err := refreshStatusView(v.Name, g, e, reload); err != nil {
+		if err := refreshStatusView(v.Name, g, r, reload); err != nil {
 			return err
 		}
 	}
diff --git a/gui/unstagedview.go b/gui/unstagedview.go
index ce19388..f5b6e43 100644
--- a/gui/unstagedview.go
+++ b/gui/unstagedview.go
@@ -23,27 +23,27 @@ func (gui *Gui) openUnStagedView(g *gocui.Gui) error {
 }
 
 func (gui *Gui) addChanges(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
+	r := gui.getSelectedRepository()
 
 	_, cy := v.Cursor()
 	_, oy := v.Origin()
 	if len(unstagedFiles) <= 0 || len(unstagedFiles) < cy+oy {
 		return nil
 	}
-	if err := command.Add(e, unstagedFiles[cy+oy], command.AddOptions{}); err != nil {
+	if err := command.Add(r, unstagedFiles[cy+oy], command.AddOptions{}); err != nil {
 		return err
 	}
 
-	return refreshAllStatusView(g, e, true)
+	return refreshAllStatusView(g, r, true)
 }
 
 func (gui *Gui) addAllChanges(g *gocui.Gui, v *gocui.View) error {
-	e := gui.getSelectedRepository()
-	if err := command.AddAll(e, command.AddOptions{}); err != nil {
+	r := gui.getSelectedRepository()
+	if err := command.AddAll(r, command.AddOptions{}); err != nil {
 		return err
 	}
 
-	return refreshAllStatusView(g, e, true)
+	return refreshAllStatusView(g, r, true)
 }
 
 // refresh the main view and re-render the repository representations
diff --git a/gui/util-textstyle.go b/gui/util-textstyle.go
index f14e6c2..01a24c3 100644
--- a/gui/util-textstyle.go
+++ b/gui/util-textstyle.go
@@ -51,32 +51,32 @@ var (
 
 // this function handles the render and representation of the repository
 // TODO: cleanup is required, right now it looks too complicated
-func (gui *Gui) repositoryLabel(e *git.RepoEntity) string {
+func (gui *Gui) repositoryLabel(r *git.Repository) string {
 
 	var prefix string
-	if e.Branch.Pushables != "?" {
-		prefix = prefix + pushable + ws + e.Branch.Pushables +
-			ws + pullable + ws + e.Branch.Pullables
+	if r.Branch.Pushables != "?" {
+		prefix = prefix + pushable + ws + r.Branch.Pushables +
+			ws + pullable + ws + r.Branch.Pullables
 	} else {
-		prefix = prefix + pushable + ws + yellow.Sprint(e.Branch.Pushables) +
-			ws + pullable + ws + yellow.Sprint(e.Branch.Pullables)
+		prefix = prefix + pushable + ws + yellow.Sprint(r.Branch.Pushables) +
+			ws + pullable + ws + yellow.Sprint(r.Branch.Pullables)
 	}
 
 	var repoName string
-	se := gui.getSelectedRepository()
-	if se == e {
+	sr := gui.getSelectedRepository()
+	if sr == r {
 		prefix = prefix + selectionIndicator
-		repoName = green.Sprint(e.Name)
+		repoName = green.Sprint(r.Name)
 	} else {
 		prefix = prefix + ws
-		repoName = e.Name
+		repoName = r.Name
 	}
 	// some branch names can be really long, in that times I hope the first
 	// characters are important and meaningful
-	branch := adjustTextLength(e.Branch.Name, maxBranchLength)
+	branch := adjustTextLength(r.Branch.Name, maxBranchLength)
 	prefix = prefix + string(cyan.Sprint(branch))
 
-	if !e.Branch.Clean {
+	if !r.Branch.Clean {
 		prefix = prefix + ws + dirty + ws
 	} else {
 		prefix = prefix + ws
@@ -84,8 +84,8 @@ func (gui *Gui) repositoryLabel(e *git.RepoEntity) string {
 
 	var suffix string
 	// rendering the satus according to repository's state
-	if e.State() == git.Queued {
-		if inQueue, j := gui.State.Queue.IsInTheQueue(e); inQueue {
+	if r.State() == git.Queued {
+		if inQueue, j := gui.State.Queue.IsInTheQueue(r); inQueue {
 			switch mode := j.JobType; mode {
 			case job.FetchJob:
 				suffix = blue.Sprint(queuedSymbol)
@@ -98,15 +98,15 @@ func (gui *Gui) repositoryLabel(e *git.RepoEntity) string {
 			}
 		}
 		return prefix + repoName + ws + suffix
-	} else if e.State() == git.Working {
+	} else if r.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 e.State() == git.Success {
+	} else if r.State() == git.Success {
 		return prefix + repoName + ws + green.Sprint(successSymbol)
-	} else if e.State() == git.Paused {
+	} else if r.State() == git.Paused {
 		return prefix + repoName + ws + yellow.Sprint("authentication required (u)")
-	} else if e.State() == git.Fail {
-		return prefix + repoName + ws + red.Sprint(failSymbol) + ws + red.Sprint(e.Message)
+	} else if r.State() == git.Fail {
+		return prefix + repoName + ws + red.Sprint(failSymbol) + ws + red.Sprint(r.Message)
 	}
 	return prefix + repoName
 }