Merge pull request jesseduffield#1501 from Ryooooooga/feature/fix-com…

…mand

Improved command execution

pkg/commands/branches.go

@@ -11,7 +11,7 @@ import (
 
 // NewBranch create new branch
 func (c *GitCommand) NewBranch(name string, base string) error {
-	return c.RunCommand("git checkout -b %s %s", name, base)
+	return c.RunCommand("git checkout -b %s %s", c.OSCommand.Quote(name), c.OSCommand.Quote(base))
 }
 
 // CurrentBranchName get the current branch name and displayname.
@@ -47,7 +47,7 @@ func (c *GitCommand) DeleteBranch(branch string, force bool) error {
 		command = "git branch -D"
 	}
 
-	return c.OSCommand.RunCommand("%s %s", command, branch)
+	return c.OSCommand.RunCommand("%s %s", command, c.OSCommand.Quote(branch))
 }
 
 // Checkout checks out a branch (or commit), with --force if you set the force arg to true
@@ -61,7 +61,7 @@ func (c *GitCommand) Checkout(branch string, options CheckoutOptions) error {
 	if options.Force {
 		forceArg = " --force"
 	}
-	return c.OSCommand.RunCommandWithOptions(fmt.Sprintf("git checkout%s %s", forceArg, branch), oscommands.RunCommandOptions{EnvVars: options.EnvVars})
+	return c.OSCommand.RunCommandWithOptions(fmt.Sprintf("git checkout%s %s", forceArg, c.OSCommand.Quote(branch)), oscommands.RunCommandOptions{EnvVars: options.EnvVars})
 }
 
 // GetBranchGraph gets the color-formatted graph of the log for the given branch
@@ -73,24 +73,24 @@ func (c *GitCommand) GetBranchGraph(branchName string) (string, error) {
 }
 
 func (c *GitCommand) GetUpstreamForBranch(branchName string) (string, error) {
-	output, err := c.RunCommandWithOutput("git rev-parse --abbrev-ref --symbolic-full-name %s@{u}", branchName)
+	output, err := c.RunCommandWithOutput("git rev-parse --abbrev-ref --symbolic-full-name %s@{u}", c.OSCommand.Quote(branchName))
 	return strings.TrimSpace(output), err
 }
 
 func (c *GitCommand) GetBranchGraphCmdStr(branchName string) string {
 	branchLogCmdTemplate := c.Config.GetUserConfig().Git.BranchLogCmd
 	templateValues := map[string]string{
-		"branchName": branchName,
+		"branchName": c.OSCommand.Quote(branchName),
 	}
 	return utils.ResolvePlaceholderString(branchLogCmdTemplate, templateValues)
 }
 
 func (c *GitCommand) SetUpstreamBranch(upstream string) error {
-	return c.RunCommand("git branch -u %s", upstream)
+	return c.RunCommand("git branch -u %s", c.OSCommand.Quote(upstream))
 }
 
 func (c *GitCommand) SetBranchUpstream(remoteName string, remoteBranchName string, branchName string) error {
-	return c.RunCommand("git branch --set-upstream-to=%s/%s %s", remoteName, remoteBranchName, branchName)
+	return c.RunCommand("git branch --set-upstream-to=%s/%s %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(remoteBranchName), c.OSCommand.Quote(branchName))
 }
 
 func (c *GitCommand) GetCurrentBranchUpstreamDifferenceCount() (string, string) {
@@ -124,7 +124,7 @@ type MergeOpts struct {
 func (c *GitCommand) Merge(branchName string, opts MergeOpts) error {
 	mergeArgs := c.Config.GetUserConfig().Git.Merging.Args
 
-	command := fmt.Sprintf("git merge --no-edit %s %s", mergeArgs, branchName)
+	command := fmt.Sprintf("git merge --no-edit %s %s", mergeArgs, c.OSCommand.Quote(branchName))
 	if opts.FastForwardOnly {
 		command = fmt.Sprintf("%s --ff-only", command)
 	}
@@ -144,18 +144,18 @@ func (c *GitCommand) IsHeadDetached() bool {
 
 // ResetHardHead runs `git reset --hard`
 func (c *GitCommand) ResetHard(ref string) error {
-	return c.RunCommand("git reset --hard " + ref)
+	return c.RunCommand("git reset --hard " + c.OSCommand.Quote(ref))
 }
 
 // ResetSoft runs `git reset --soft HEAD`
 func (c *GitCommand) ResetSoft(ref string) error {
-	return c.RunCommand("git reset --soft " + ref)
+	return c.RunCommand("git reset --soft " + c.OSCommand.Quote(ref))
 }
 
 func (c *GitCommand) ResetMixed(ref string) error {
-	return c.RunCommand("git reset --mixed " + ref)
+	return c.RunCommand("git reset --mixed " + c.OSCommand.Quote(ref))
 }
 
 func (c *GitCommand) RenameBranch(oldName string, newName string) error {
-	return c.RunCommand("git branch --move %s %s", oldName, newName)
+	return c.RunCommand("git branch --move %s %s", c.OSCommand.Quote(oldName), c.OSCommand.Quote(newName))
 }

pkg/commands/files.go

@@ -123,14 +123,14 @@ func (c *GitCommand) DiscardAllFileChanges(file *models.File) error {
 		if err := c.RunCommand("git checkout --ours --  %s", quotedFileName); err != nil {
 			return err
 		}
-		if err := c.RunCommand("git add %s", quotedFileName); err != nil {
+		if err := c.RunCommand("git add -- %s", quotedFileName); err != nil {
 			return err
 		}
 		return nil
 	}
 
 	if file.ShortStatus == "DU" {
-		return c.RunCommand("git rm %s", quotedFileName)
+		return c.RunCommand("git rm -- %s", quotedFileName)
 	}
 
 	// if the file isn't tracked, we assume you want to delete it
@@ -299,7 +299,7 @@ func (c *GitCommand) DiscardAnyUnstagedFileChanges() error {
 
 // RemoveTrackedFiles will delete the given file(s) even if they are currently tracked
 func (c *GitCommand) RemoveTrackedFiles(name string) error {
-	return c.RunCommand("git rm -r --cached %s", c.OSCommand.Quote(name))
+	return c.RunCommand("git rm -r --cached -- %s", c.OSCommand.Quote(name))
 }
 
 // RemoveUntrackedFiles runs `git clean -fd`

pkg/commands/loading_commits.go

@@ -322,7 +322,7 @@ func (c *CommitListBuilder) getMergeBase(refName string) (string, error) {
 	}
 
 	// swallowing error because it's not a big deal; probably because there are no commits yet
-	output, _ := c.OSCommand.RunCommandWithOutput("git merge-base %s %s", refName, baseBranch)
+	output, _ := c.OSCommand.RunCommandWithOutput("git merge-base %s %s", c.OSCommand.Quote(refName), c.OSCommand.Quote(baseBranch))
 	return ignoringWarnings(output), nil
 }
 
@@ -339,7 +339,7 @@ func ignoringWarnings(commandOutput string) string {
 // getFirstPushedCommit returns the first commit SHA which has been pushed to the ref's upstream.
 // all commits above this are deemed unpushed and marked as such.
 func (c *CommitListBuilder) getFirstPushedCommit(refName string) (string, error) {
-	output, err := c.OSCommand.RunCommandWithOutput("git merge-base %s %s@{u}", refName, refName)
+	output, err := c.OSCommand.RunCommandWithOutput("git merge-base %s %s@{u}", c.OSCommand.Quote(refName), c.OSCommand.Quote(refName))
 	if err != nil {
 		return "", err
 	}
@@ -362,7 +362,7 @@ func (c *CommitListBuilder) getLogCmd(opts GetCommitsOptions) *exec.Cmd {
 	return c.OSCommand.ExecutableFromString(
 		fmt.Sprintf(
 			"git log %s --oneline --pretty=format:\"%%H%s%%at%s%%aN%s%%d%s%%p%s%%s\" %s --abbrev=%d --date=unix %s",
-			opts.RefName,
+			c.OSCommand.Quote(opts.RefName),
 			SEPARATION_CHAR,
 			SEPARATION_CHAR,
 			SEPARATION_CHAR,

pkg/commands/remotes.go

@@ -5,31 +5,31 @@ import (
 )
 
 func (c *GitCommand) AddRemote(name string, url string) error {
-	return c.RunCommand("git remote add %s %s", name, url)
+	return c.RunCommand("git remote add %s %s", c.OSCommand.Quote(name), c.OSCommand.Quote(url))
 }
 
 func (c *GitCommand) RemoveRemote(name string) error {
-	return c.RunCommand("git remote remove %s", name)
+	return c.RunCommand("git remote remove %s", c.OSCommand.Quote(name))
 }
 
 func (c *GitCommand) RenameRemote(oldRemoteName string, newRemoteName string) error {
-	return c.RunCommand("git remote rename %s %s", oldRemoteName, newRemoteName)
+	return c.RunCommand("git remote rename %s %s", c.OSCommand.Quote(oldRemoteName), c.OSCommand.Quote(newRemoteName))
 }
 
 func (c *GitCommand) UpdateRemoteUrl(remoteName string, updatedUrl string) error {
-	return c.RunCommand("git remote set-url %s %s", remoteName, updatedUrl)
+	return c.RunCommand("git remote set-url %s %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(updatedUrl))
 }
 
 func (c *GitCommand) DeleteRemoteBranch(remoteName string, branchName string, promptUserForCredential func(string) string) error {
-	command := fmt.Sprintf("git push %s --delete %s", remoteName, branchName)
+	command := fmt.Sprintf("git push %s --delete %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(branchName))
 	return c.OSCommand.DetectUnamePass(command, promptUserForCredential)
 }
 
 // CheckRemoteBranchExists Returns remote branch
 func (c *GitCommand) CheckRemoteBranchExists(branchName string) bool {
 	_, err := c.OSCommand.RunCommandWithOutput(
 		"git show-ref --verify -- refs/remotes/origin/%s",
-		branchName,
+		c.OSCommand.Quote(branchName),
 	)
 
 	return err == nil

pkg/commands/submodules.go

@@ -119,7 +119,7 @@ func (c *GitCommand) SubmoduleAdd(name string, path string, url string) error {
 
 func (c *GitCommand) SubmoduleUpdateUrl(name string, path string, newUrl string) error {
 	// the set-url command is only for later git versions so we're doing it manually here
-	if err := c.RunCommand("git config --file .gitmodules submodule.%s.url %s", c.OSCommand.Quote(name), newUrl); err != nil {
+	if err := c.RunCommand("git config --file .gitmodules submodule.%s.url %s", c.OSCommand.Quote(name), c.OSCommand.Quote(newUrl)); err != nil {
 		return err
 	}
 

pkg/commands/sync.go

@@ -19,7 +19,7 @@ func (c *GitCommand) Push(branchName string, force bool, upstream string, args s
 
 	setUpstreamArg := ""
 	if upstream != "" {
-		setUpstreamArg = "--set-upstream " + upstream
+		setUpstreamArg = "--set-upstream " + c.OSCommand.Quote(upstream)
 	}
 
 	cmd := fmt.Sprintf("git push %s %s %s %s", followTagsFlag, forceFlag, setUpstreamArg, args)
@@ -37,10 +37,10 @@ func (c *GitCommand) Fetch(opts FetchOptions) error {
 	command := "git fetch"
 
 	if opts.RemoteName != "" {
-		command = fmt.Sprintf("%s %s", command, opts.RemoteName)
+		command = fmt.Sprintf("%s %s", command, c.OSCommand.Quote(opts.RemoteName))
 	}
 	if opts.BranchName != "" {
-		command = fmt.Sprintf("%s %s", command, opts.BranchName)
+		command = fmt.Sprintf("%s %s", command, c.OSCommand.Quote(opts.BranchName))
 	}
 
 	return c.OSCommand.DetectUnamePass(command, func(question string) string {
@@ -52,12 +52,12 @@ func (c *GitCommand) Fetch(opts FetchOptions) error {
 }
 
 func (c *GitCommand) FastForward(branchName string, remoteName string, remoteBranchName string, promptUserForCredential func(string) string) error {
-	command := fmt.Sprintf("git fetch %s %s:%s", remoteName, remoteBranchName, branchName)
+	command := fmt.Sprintf("git fetch %s %s:%s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(remoteBranchName), c.OSCommand.Quote(branchName))
 	return c.OSCommand.DetectUnamePass(command, promptUserForCredential)
 }
 
 func (c *GitCommand) FetchRemote(remoteName string, promptUserForCredential func(string) string) error {
-	command := fmt.Sprintf("git fetch %s", remoteName)
+	command := fmt.Sprintf("git fetch %s", c.OSCommand.Quote(remoteName))
 	return c.OSCommand.DetectUnamePass(command, promptUserForCredential)
 }
 

pkg/commands/tags.go

@@ -3,14 +3,14 @@ package commands
 import "fmt"
 
 func (c *GitCommand) CreateLightweightTag(tagName string, commitSha string) error {
-	return c.RunCommand("git tag %s %s", tagName, commitSha)
+	return c.RunCommand("git tag -- %s %s", c.OSCommand.Quote(tagName), commitSha)
 }
 
 func (c *GitCommand) DeleteTag(tagName string) error {
-	return c.RunCommand("git tag -d %s", tagName)
+	return c.RunCommand("git tag -d %s", c.OSCommand.Quote(tagName))
 }
 
 func (c *GitCommand) PushTag(remoteName string, tagName string, promptUserForCredential func(string) string) error {
-	command := fmt.Sprintf("git push %s %s", remoteName, tagName)
+	command := fmt.Sprintf("git push %s %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(tagName))
 	return c.OSCommand.DetectUnamePass(command, promptUserForCredential)
 }